vibe-coding-master 0.7.30 → 0.7.32

package/README.md

@@ -503,11 +503,14 @@ shared or current-role target and its supporting evidence. Adds and updates
 also state why the memory is necessary, the impact of omitting it, and whether
 the knowledge belongs in memory or a durable document. Harness Engineer first
 reviews every existing memory entry, recording its retention reason, removal
-impact, and durable-document disposition, then evaluates the proposals and
-records the resulting changes in the Retrospective report. VCM validates that
-report structure before applying the reviewed memory. Harness Engineer review
-and retrospective work remain tool role activity and do not participate in
-Round completion.
+impact, and durable-document disposition, then evaluates every proposal item
+independently. Each Add or Update decision records why the memory is necessary,
+what happens if it is absent, whether it belongs in memory or a durable
+document, and the exact final memory content when retained. VCM validates that
+every candidate has one matching decision and that the reviewed memory files
+implement those decisions before applying them. Harness Engineer review and
+retrospective work remain tool role activity and do not participate in Round
+completion.
 
 When Auto Memory is disabled, Review Task Harness does not collect proposals or
 ask Harness Engineer to update memory. When enabled, both automatic and manual

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

@@ -6,8 +6,8 @@ import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { readVcmMemoryBlock, replaceVcmMemoryBlock } from "../templates/harness/memory-block.js";
 import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH, architectPlanningCandidateSnapshotPath, MEMORY_REVIEW_RUNS_ROOT, MEMORY_REVIEW_STATE_PATH } from "./memory-review-paths.js";
-import { validateMemoryProposal } from "./memory-proposal-validation.js";
-import { validateMemoryReviewReport } from "./memory-review-validation.js";
+import { parseMemoryProposal, validateMemoryProposal } from "./memory-proposal-validation.js";
+import { parseMemoryReviewReport, validateMemoryReviewOutput } from "./memory-review-validation.js";
 const MEMORY_FILE_DEFINITIONS = [
     { path: "CLAUDE.md", title: "Shared Memory" },
     { path: ".claude/agents/project-manager.md", title: "Project Manager Memory", role: "project-manager" },
@@ -251,6 +251,7 @@ export function createAutoMemoryService(deps) {
                 statusCode: 409
             });
         }
+        const proposalCandidates = await readReviewCandidates(taskRepoRoot, state);
         const timestamp = now();
         state.reviewPromptDispatchedAt = timestamp;
         state.retrospectiveReportPath = retrospectiveReportPath;
@@ -263,7 +264,7 @@ export function createAutoMemoryService(deps) {
             roleDraftsPath: path.join(runRoot, "drafts"),
             currentMemoryPath: path.join(runRoot, "before"),
             reviewedMemoryPath: path.join(runRoot, "after"),
-            proposalRoles: state.drafts.map((draft) => draft.role),
+            proposalCandidates,
             ...(planningCandidatePath
                 ? { planningCandidatePath: resolveRepoPath(taskRepoRoot, planningCandidatePath) }
                 : {})
@@ -360,11 +361,24 @@ export function createAutoMemoryService(deps) {
                 await failReview(input.taskRepoRoot, state, "Task Harness Retrospective did not write the required retrospective report.");
                 return true;
             }
-            const report = await deps.fs.readText(state.retrospectiveReportPath);
-            const currentMemorySnapshot = await readRunMemorySet(input.taskRepoRoot, state.runId, "before");
-            const reportError = validateMemoryReviewReport(report, state.drafts.map((draft) => draft.role), hasSubstantiveMemory(currentMemorySnapshot));
-            if (reportError) {
-                await failReview(input.taskRepoRoot, state, `Task Harness Retrospective memory review report ${reportError}.`);
+            try {
+                const report = await deps.fs.readText(state.retrospectiveReportPath);
+                const currentMemorySnapshot = await readRunMemorySet(input.taskRepoRoot, state.runId, "before");
+                const reviewedMemorySnapshot = await readRunMemorySet(input.taskRepoRoot, state.runId, "after");
+                const candidates = await readReviewCandidates(input.taskRepoRoot, state);
+                const reportResult = parseMemoryReviewReport(report, candidates, hasSubstantiveMemory(currentMemorySnapshot));
+                if (reportResult.error) {
+                    await failReview(input.taskRepoRoot, state, `Task Harness Retrospective memory review report ${reportResult.error}.`);
+                    return true;
+                }
+                const outputError = await validateReviewedMemoryOutput(input.taskRepoRoot, currentMemorySnapshot, reviewedMemorySnapshot, reportResult.decisions ?? []);
+                if (outputError) {
+                    await failReview(input.taskRepoRoot, state, `Task Harness Retrospective reviewed memory ${outputError}.`);
+                    return true;
+                }
+            }
+            catch (error) {
+                await failReview(input.taskRepoRoot, state, `Task Harness Retrospective memory review validation failed: ${errorMessage(error)}`);
                 return true;
             }
             await applyReviewedMemory(input.taskRepoRoot, state);
@@ -525,6 +539,41 @@ export function createAutoMemoryService(deps) {
             ? relativePath
             : undefined;
     }
+    async function readReviewCandidates(taskRepoRoot, state) {
+        const candidates = [];
+        for (const draft of state.drafts) {
+            const draftPath = resolveRepoPath(taskRepoRoot, draft.path);
+            const parsed = parseMemoryProposal(await deps.fs.readText(draftPath));
+            if (!parsed.proposal) {
+                throw new Error(`${draft.role} memory draft ${parsed.error ?? "could not be parsed"}`);
+            }
+            candidates.push(...toReviewCandidates(draft.role, draft.role, parsed.proposal.items));
+        }
+        const planningCandidatePath = await findPlanningCandidateSnapshot(taskRepoRoot, state.runId);
+        if (planningCandidatePath) {
+            const parsed = parseMemoryProposal(await deps.fs.readText(resolveRepoPath(taskRepoRoot, planningCandidatePath)));
+            if (!parsed.proposal) {
+                throw new Error(`Architect planning-session memory candidate ${parsed.error ?? "could not be parsed"}`);
+            }
+            candidates.push(...toReviewCandidates("architect-planning", "architect", parsed.proposal.items));
+        }
+        return candidates;
+    }
+    async function validateReviewedMemoryOutput(taskRepoRoot, before, after, decisions) {
+        return validateMemoryReviewOutput({
+            before: memorySetByTarget(before),
+            after: memorySetByTarget(after),
+            decisions,
+            durableDocExists: async (durableDocPath) => {
+                try {
+                    return await deps.fs.pathExists(resolveRepoPath(taskRepoRoot, durableDocPath));
+                }
+                catch {
+                    return false;
+                }
+            }
+        });
+    }
     async function applyReviewedMemory(taskRepoRoot, state) {
         try {
             const before = await readRunMemorySet(taskRepoRoot, state.runId, "before");
@@ -756,6 +805,37 @@ export async function assertMemoryBlocksInstalled(fs, taskRepoRoot) {
 function currentDraft(state) {
     return state.drafts.find((draft) => draft.status !== "completed");
 }
+function toReviewCandidates(source, currentRole, items) {
+    return items.map((item) => ({
+        id: `${source}:${item.operation}:${item.ordinal}`,
+        source,
+        operation: item.operation,
+        target: item.target === "shared" ? "shared" : currentRole,
+        ...(item.content ? { content: item.content } : {}),
+        ...(item.existing ? { existing: item.existing } : {})
+    }));
+}
+function memoryPathForTarget(target) {
+    if (target === "shared") {
+        return "CLAUDE.md";
+    }
+    const definition = MEMORY_FILE_DEFINITIONS.find((candidate) => "role" in candidate && candidate.role === target);
+    if (!definition) {
+        throw new Error(`Missing memory file definition for review target: ${target}`);
+    }
+    return definition.path;
+}
+function memorySetByTarget(memory) {
+    return {
+        shared: memory["CLAUDE.md"],
+        "project-manager": memory[memoryPathForTarget("project-manager")],
+        architect: memory[memoryPathForTarget("architect")],
+        coder: memory[memoryPathForTarget("coder")],
+        tester: memory[memoryPathForTarget("tester")],
+        reviewer: memory[memoryPathForTarget("reviewer")],
+        "harness-engineer": memory[memoryPathForTarget("harness-engineer")]
+    };
+}
 function toActiveReview(state) {
     return {
         runId: state.runId,

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

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
-import { CODE_DIFF_SOURCES, GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
+import { CODE_DIFF_FINDING_SCOPES, CODE_DIFF_SOURCES, GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
 import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
@@ -38,6 +38,7 @@ const VALIDATION_ANALYSIS_FIELDS = [
     "Boundary And Failure Coverage",
     "Public Contract Coverage",
     "Test Integrity",
+    "Test Infrastructure",
     "Skips And Gaps",
     "User Approval And Gap Disposition",
     "Validation Readiness"
@@ -91,6 +92,7 @@ const CORE_INPUT_ARTIFACTS = {
     "validation-adequacy": ".ai/vcm/handoffs/test-report.md"
 };
 const VALID_SEVERITIES = new Set(["critical", "high", "medium", "low"]);
+const VALID_CODE_DIFF_FINDING_SCOPES = new Set(CODE_DIFF_FINDING_SCOPES);
 export function createGateReviewService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const reportPollIntervalMs = deps.reportPollIntervalMs ?? DEFAULT_REPORT_POLL_INTERVAL_MS;
@@ -1067,11 +1069,18 @@ async function readValidationReportError(fs, taskRepoRoot) {
     const absolutePath = resolveRepoPath(taskRepoRoot, relativePath);
     const content = await fs.pathExists(absolutePath) ? await fs.readText(absolutePath) : null;
     const check = checkMarkdownArtifact("test-report", relativePath, content);
-    if (check.status === "ok") {
-        return undefined;
+    if (check.status !== "ok") {
+        return `${relativePath} is incomplete and cannot start validation-adequacy review. `
+            + formatValidationArtifactFailure(check, content);
+    }
+    const infrastructureStatus = matchField(extractMarkdownSection(content ?? "", "Test Infrastructure") ?? "", "Status");
+    if (infrastructureStatus === "repair-required") {
+        return `${relativePath} cannot start validation-adequacy review while Test Infrastructure Status is repair-required. Route Tester repair first.`;
+    }
+    if (infrastructureStatus === "production-change-required") {
+        return `${relativePath} cannot start validation-adequacy review while Test Infrastructure Status is production-change-required. Route the active flow's implementation-failure branch first.`;
     }
-    return `${relativePath} is incomplete and cannot start validation-adequacy review. `
-        + formatValidationArtifactFailure(check, content);
+    return undefined;
 }
 async function readCodeDiffPrerequisiteError(deps, context, index) {
     const reportError = await readValidationReportError(deps.fs, context.taskRepoRoot);
@@ -1367,11 +1376,13 @@ function validateRequestChangeFindings(findings) {
     }
 }
 function validateCodeDiffFindings(findings) {
-    const incomplete = findings.find((finding) => !finding.file?.trim() || !finding.location?.trim());
+    const incomplete = findings.find((finding) => (!finding.file?.trim()
+        || !finding.location?.trim()
+        || !finding.scope));
     if (incomplete) {
         throw new VcmError({
             code: "GATE_REVIEW_CODE_DIFF_FINDING_LOCATION_MISSING",
-            message: `Code-diff finding ${incomplete.title} must contain File and Line Or Symbol.`,
+            message: `Code-diff finding ${incomplete.title} must contain File, Line Or Symbol, and Finding Scope.`,
             statusCode: 500
         });
     }
@@ -1465,6 +1476,7 @@ function extractFindings(content) {
             file: matchField(block, "file"),
             line: parsePositiveInteger(matchField(block, "line")),
             location: matchField(block, "line or symbol"),
+            scope: normalizeCodeDiffFindingScope(matchField(block, "finding scope")),
             evidence: matchField(block, "evidence") ?? "",
             expected: matchField(block, "expected") ?? "",
             gap: matchField(block, "gap") ?? "",
@@ -1527,6 +1539,12 @@ function normalizeSeverity(value) {
         ? normalized
         : undefined;
 }
+function normalizeCodeDiffFindingScope(value) {
+    const normalized = typeof value === "string" ? value.toLowerCase() : "";
+    return VALID_CODE_DIFF_FINDING_SCOPES.has(normalized)
+        ? normalized
+        : undefined;
+}
 function normalizeCallbackStatus(value) {
     return value === "not_sent" || value === "sent" || value === "skipped" || value === "failed"
         ? value

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

@@ -260,9 +260,13 @@ export function createHarnessFeedbackService(deps) {
                     "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.",
+                    "Then evaluate every proposal item independently. Do not accept or reject a whole role draft as one decision.",
+                    "For every Add or Update candidate, independently explain why the memory is necessary, what fails if it is absent, and why memory or a durable document is the correct destination.",
+                    "Do not copy the proposer rationale as the review. Verify it against current code, durable documentation, and final task evidence.",
                     "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.",
+                    "Final content must be one exact line written to the selected reviewed-memory file. Use none when the decision does not keep memory.",
+                    "For keep-in-memory use Durable doc disposition: memory. For keep-memory-reference use memory-reference. For move-to-durable-doc use durable-doc.",
                     "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.",
@@ -272,8 +276,10 @@ export function createHarnessFeedbackService(deps) {
                     "## Memory Review",
                     "Existing memory reviewed: complete",
                     "",
-                    "### Proposal Dispositions",
-                    ...memoryReview.proposalRoles.map((role) => `- ${role}: accepted|rejected|no-change`),
+                    "### Proposal Decisions",
+                    ...(memoryReview.proposalCandidates.length > 0
+                        ? memoryReview.proposalCandidates.flatMap(renderMemoryProposalDecisionTemplate)
+                        : ["none"]),
                     "",
                     "### Existing Memory Decisions",
                     "#### Item 1",
@@ -299,6 +305,38 @@ export function createHarnessFeedbackService(deps) {
             "End your turn after writing the result."
         ].join("\n");
     }
+    function renderMemoryProposalDecisionTemplate(candidate) {
+        if (candidate.operation === "remove") {
+            return [
+                `#### Candidate ${candidate.id}`,
+                `Source: ${candidate.source}`,
+                "Operation: remove",
+                `Target: ${candidate.target}`,
+                `Existing: ${candidate.existing}`,
+                "Decision: remove|retain",
+                "Reason: <why the proposed removal should be applied or rejected>",
+                "Evidence checked: <current code, durable documentation, or final task evidence>",
+                ""
+            ];
+        }
+        return [
+            `#### Candidate ${candidate.id}`,
+            `Source: ${candidate.source}`,
+            `Operation: ${candidate.operation}`,
+            `Target: ${candidate.target}`,
+            `Candidate: ${candidate.content}`,
+            "Decision: keep-in-memory|keep-memory-reference|move-to-durable-doc|reject",
+            "Final target: shared|project-manager|architect|coder|tester|reviewer|harness-engineer|none",
+            "Why memory is necessary: <independent reason, or why it is not necessary>",
+            "Impact if absent: <specific impact, or why no durable impact exists>",
+            "Durable doc disposition: memory|durable-doc|memory-reference",
+            "Durable doc analysis: <why this destination is correct>",
+            "Durable doc path: <none or a project-relative durable doc path>",
+            "Evidence checked: <current code, durable documentation, or final task evidence>",
+            "Final content: <exact one-line reviewed-memory content or none>",
+            ""
+        ];
+    }
     function buildPendingFeedbackPrompt(repoRoot, feedbackPath) {
         return [
             "[VCM Harness Feedback]",

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

@@ -1,20 +1,23 @@
 const OPERATIONS = ["Add", "Update", "Remove"];
 export function validateMemoryProposal(content) {
+    return parseMemoryProposal(content).error;
+}
+export function parseMemoryProposal(content) {
     if (!/^# Memory Proposal\s*$/m.test(content)) {
-        return "is missing the # Memory Proposal heading";
+        return { error: "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";
+        return { error: "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";
+        return { error: "must contain only the Add, Update, and Remove sections, exactly once and in that order" };
     }
-    let itemCount = 0;
+    const items = [];
     for (let index = 0; index < sections.length; index += 1) {
         const section = sections[index];
         const operation = section[1];
@@ -22,30 +25,31 @@ export function validateMemoryProposal(content) {
         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;
+        const result = parseOperationBody(operation, content.slice(bodyStart, bodyEnd));
+        if (result.error) {
+            return { error: result.error };
         }
-        itemCount += result;
+        items.push(...result.items);
     }
     const decision = decisionMatches[0][1];
-    if (decision === "no-change" && itemCount !== 0) {
-        return "uses Decision: no-change but contains a memory item";
+    if (decision === "no-change" && items.length !== 0) {
+        return { error: "uses Decision: no-change but contains a memory item" };
     }
-    if (decision === "update" && itemCount === 0) {
-        return "uses Decision: update without a structured memory item";
+    if (decision === "update" && items.length === 0) {
+        return { error: "uses Decision: update without a structured memory item" };
     }
-    return undefined;
+    return { proposal: { decision, items } };
 }
-function validateOperationBody(operation, rawBody) {
+function parseOperationBody(section, rawBody) {
     const body = rawBody.trim();
     if (body === "none") {
-        return 0;
+        return { items: [] };
     }
     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`;
+        return { items: [], error: `${section} must contain none or one or more ### Item N blocks` };
     }
+    const items = [];
     for (let index = 0; index < itemHeadings.length; index += 1) {
         const heading = itemHeadings[index];
         const itemStart = (heading.index ?? 0) + heading[0].length;
@@ -53,28 +57,69 @@ function validateOperationBody(operation, rawBody) {
             ? itemHeadings[index + 1].index ?? body.length
             : body.length;
         const item = body.slice(itemStart, itemEnd).trim();
-        const expectedPattern = operation === "Add"
+        const expectedPattern = section === "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"
+            : section === "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"
+        const match = expectedPattern.exec(item);
+        if (!match) {
+            const fields = section === "Add"
                 ? "Target, Content, Reason, Impact if absent, Durable doc disposition, Durable doc path, and Evidence"
-                : operation === "Update"
+                : section === "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`;
+            return {
+                items: [],
+                error: `${section} ${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`;
-            }
+        const parsed = parseProposalItem(section, index + 1, match);
+        if (parsed.durableDocDisposition
+            && ((parsed.durableDocDisposition === "memory" && parsed.durableDocPath !== "none")
+                || (parsed.durableDocDisposition !== "memory" && parsed.durableDocPath === "none"))) {
+            return {
+                items: [],
+                error: `${section} ${heading[0].trim()} must use Durable doc path: none only with Durable doc disposition: memory`
+            };
         }
+        items.push(parsed);
+    }
+    return { items };
+}
+function parseProposalItem(section, ordinal, match) {
+    if (section === "Add") {
+        return {
+            operation: "add",
+            ordinal,
+            target: match[1],
+            content: match[2],
+            reason: match[3],
+            impactIfAbsent: match[4],
+            durableDocDisposition: match[5],
+            durableDocPath: match[6],
+            evidence: match[7]
+        };
+    }
+    if (section === "Update") {
+        return {
+            operation: "update",
+            ordinal,
+            target: match[1],
+            existing: match[2],
+            content: match[3],
+            reason: match[4],
+            impactIfAbsent: match[5],
+            durableDocDisposition: match[6],
+            durableDocPath: match[7],
+            evidence: match[8]
+        };
     }
-    return itemHeadings.length;
+    return {
+        operation: "remove",
+        ordinal,
+        target: match[1],
+        existing: match[2],
+        evidence: match[3]
+    };
 }

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

@@ -1,47 +1,222 @@
-export function validateMemoryReviewReport(content, proposalRoles, hasExistingMemory = false) {
+export function validateMemoryReviewReport(content, candidates, hasExistingMemory = false) {
+    return parseMemoryReviewReport(content, candidates, hasExistingMemory).error;
+}
+export function parseMemoryReviewReport(content, candidates, hasExistingMemory = false) {
     const memoryReview = /^## Memory Review\s*$/m.exec(content);
     if (!memoryReview || memoryReview.index === undefined) {
-        return "is missing the ## Memory Review section";
+        return { error: "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";
+        return { error: "must declare Existing memory reviewed: complete" };
     }
     if (!/^Reviewed memory set:[ \t]*complete[ \t]*$/m.test(section)) {
-        return "must declare Reviewed memory set: complete";
+        return { error: "must declare Reviewed memory set: complete" };
     }
-    const dispositions = extractReportSubsection(section, "Proposal Dispositions", "Existing Memory Decisions");
+    const dispositions = extractReportSubsection(section, "Proposal Decisions", "Existing Memory Decisions");
     if (dispositions === undefined) {
-        return "is missing the Proposal Dispositions subsection";
+        return { error: "is missing the Proposal Decisions 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 decisionsResult = parseProposalDecisions(dispositions, candidates);
+    if (decisionsResult.error) {
+        return decisionsResult;
     }
     const existingDecisions = extractReportSubsection(section, "Existing Memory Decisions", "Existing Memory Changes");
     if (existingDecisions === undefined) {
-        return "is missing the Existing Memory Decisions subsection";
+        return { error: "is missing the Existing Memory Decisions subsection" };
     }
     const existingDecisionError = validateExistingMemoryDecisions(existingDecisions, hasExistingMemory);
     if (existingDecisionError) {
-        return existingDecisionError;
+        return { error: existingDecisionError };
     }
     const existingChanges = extractReportSubsection(section, "Existing Memory Changes");
     if (existingChanges === undefined) {
-        return "is missing the Existing Memory Changes subsection";
+        return { error: "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 { error: `must record exactly one non-empty ${field} summary` };
+        }
+    }
+    return { decisions: decisionsResult.decisions };
+}
+export async function validateMemoryReviewOutput(input) {
+    const retainedProposalContent = new Set(input.decisions
+        .filter((decision) => (decision.decision === "keep-in-memory"
+        || decision.decision === "keep-memory-reference"))
+        .map((decision) => decision.finalContent)
+        .filter((content) => Boolean(content && content !== "none")));
+    for (const decision of input.decisions) {
+        const originalBefore = memoryLines(input.before[decision.target]);
+        const originalAfter = memoryLines(input.after[decision.target]);
+        if (decision.operation === "remove") {
+            if (decision.decision === "remove" && originalAfter.has(decision.existing ?? "")) {
+                return `still contains ${decision.candidateId}, which the report decided to remove`;
+            }
+            if (decision.decision === "retain" && !originalAfter.has(decision.existing ?? "")) {
+                return `does not retain ${decision.candidateId} as required by the report`;
+            }
+            continue;
+        }
+        const keepsMemory = decision.decision === "keep-in-memory"
+            || decision.decision === "keep-memory-reference";
+        if (keepsMemory) {
+            const finalTarget = decision.finalTarget;
+            if (!memoryLines(input.after[finalTarget]).has(decision.finalContent ?? "")) {
+                return `does not contain the exact Final content for ${decision.candidateId} in ${finalTarget}`;
+            }
+            if (decision.operation === "update"
+                && decision.existing
+                && decision.existing !== decision.finalContent
+                && originalAfter.has(decision.existing)) {
+                return `still contains the superseded Existing value for ${decision.candidateId}`;
+            }
+        }
+        else if (decision.candidate
+            && !memorySetContains(input.before, decision.candidate)
+            && memorySetContains(input.after, decision.candidate)
+            && !retainedProposalContent.has(decision.candidate)) {
+            return `contains the rejected or durable-doc-only candidate ${decision.candidateId}`;
+        }
+        if (decision.durableDocDisposition === "memory-reference"
+            && decision.durableDocPath
+            && !(await input.durableDocExists(decision.durableDocPath))) {
+            return `references a missing durable document for ${decision.candidateId}: ${decision.durableDocPath}`;
         }
     }
     return undefined;
 }
+function parseProposalDecisions(content, candidates) {
+    const body = content.trim();
+    if (candidates.length === 0) {
+        return body === "none"
+            ? { decisions: [] }
+            : { error: "Proposal Decisions must be none when no memory candidate exists" };
+    }
+    if (body === "none") {
+        return { error: "Proposal Decisions cannot be none while memory candidates exist" };
+    }
+    const headings = [...body.matchAll(/^#### Candidate ([A-Za-z0-9._:-]+)[ \t]*$/gm)];
+    if (headings.length === 0 || body.slice(0, headings[0].index).trim()) {
+        return { error: "Proposal Decisions must contain one #### Candidate <id> block per memory candidate" };
+    }
+    const expected = new Map(candidates.map((candidate) => [candidate.id, candidate]));
+    const seen = new Set();
+    const decisions = [];
+    for (let index = 0; index < headings.length; index += 1) {
+        const heading = headings[index];
+        const candidateId = heading[1];
+        if (seen.has(candidateId)) {
+            return { error: `contains duplicate proposal decision for ${candidateId}` };
+        }
+        const candidate = expected.get(candidateId);
+        if (!candidate) {
+            return { error: `contains an unexpected proposal decision for ${candidateId}` };
+        }
+        seen.add(candidateId);
+        const itemStart = (heading.index ?? 0) + heading[0].length;
+        const itemEnd = index + 1 < headings.length
+            ? headings[index + 1].index ?? body.length
+            : body.length;
+        const result = parseProposalDecision(candidate, body.slice(itemStart, itemEnd).trim());
+        if (result.error) {
+            return { error: result.error };
+        }
+        decisions.push(result.decision);
+    }
+    const missing = candidates.find((candidate) => !seen.has(candidate.id));
+    if (missing) {
+        return { error: `is missing the proposal decision for ${missing.id}` };
+    }
+    return { decisions };
+}
+function parseProposalDecision(candidate, item) {
+    if (candidate.operation === "remove") {
+        const match = /^Source:[ \t]*(\S.*)[ \t]*\nOperation:[ \t]*remove[ \t]*\nTarget:[ \t]*(shared|project-manager|architect|coder|tester|reviewer|harness-engineer)[ \t]*\nExisting:[ \t]*(\S.*)[ \t]*\nDecision:[ \t]*(remove|retain)[ \t]*\nReason:[ \t]*(\S.*)[ \t]*\nEvidence checked:[ \t]*(\S.*)[ \t]*$/.exec(item);
+        if (!match) {
+            return {
+                error: `Proposal Decision ${candidate.id} must contain one-line Source, Operation, Target, Existing, Decision, Reason, and Evidence checked fields in that order`
+            };
+        }
+        if (match[1] !== candidate.source
+            || match[2] !== candidate.target
+            || match[3] !== candidate.existing) {
+            return { error: `Proposal Decision ${candidate.id} does not match its source proposal` };
+        }
+        if (isUnresolvedReviewText(match[5]) || isUnresolvedReviewText(match[6])) {
+            return { error: `Proposal Decision ${candidate.id} must replace every review placeholder with verified reasoning and evidence` };
+        }
+        return {
+            decision: {
+                candidateId: candidate.id,
+                source: match[1],
+                operation: "remove",
+                target: match[2],
+                existing: match[3],
+                decision: match[4],
+                reason: match[5],
+                evidenceChecked: match[6]
+            }
+        };
+    }
+    const match = /^Source:[ \t]*(\S.*)[ \t]*\nOperation:[ \t]*(add|update)[ \t]*\nTarget:[ \t]*(shared|project-manager|architect|coder|tester|reviewer|harness-engineer)[ \t]*\nCandidate:[ \t]*(\S.*)[ \t]*\nDecision:[ \t]*(keep-in-memory|keep-memory-reference|move-to-durable-doc|reject)[ \t]*\nFinal target:[ \t]*(shared|project-manager|architect|coder|tester|reviewer|harness-engineer|none)[ \t]*\nWhy memory is necessary:[ \t]*(\S.*)[ \t]*\nImpact if absent:[ \t]*(\S.*)[ \t]*\nDurable doc disposition:[ \t]*(memory|durable-doc|memory-reference)[ \t]*\nDurable doc analysis:[ \t]*(\S.*)[ \t]*\nDurable doc path:[ \t]*(\S.*)[ \t]*\nEvidence checked:[ \t]*(\S.*)[ \t]*\nFinal content:[ \t]*(\S.*)[ \t]*$/.exec(item);
+    if (!match) {
+        return {
+            error: `Proposal Decision ${candidate.id} must contain one-line Source, Operation, Target, Candidate, Decision, Final target, Why memory is necessary, Impact if absent, Durable doc disposition, Durable doc analysis, Durable doc path, Evidence checked, and Final content fields in that order`
+        };
+    }
+    if (match[1] !== candidate.source
+        || match[2] !== candidate.operation
+        || match[3] !== candidate.target
+        || match[4] !== candidate.content) {
+        return { error: `Proposal Decision ${candidate.id} does not match its source proposal` };
+    }
+    if ([match[7], match[8], match[10], match[12]].some(isUnresolvedReviewText)) {
+        return { error: `Proposal Decision ${candidate.id} must replace every review placeholder with independent analysis and verified evidence` };
+    }
+    const decision = match[5];
+    const finalTarget = match[6];
+    const durableDocDisposition = match[9];
+    const durableDocPath = match[11];
+    const finalContent = match[13];
+    const keepsMemory = decision === "keep-in-memory" || decision === "keep-memory-reference";
+    if (keepsMemory && (finalTarget === "none" || finalContent === "none")) {
+        return { error: `Proposal Decision ${candidate.id} must provide Final target and Final content when keeping memory` };
+    }
+    if (!keepsMemory && (finalTarget !== "none" || finalContent !== "none")) {
+        return { error: `Proposal Decision ${candidate.id} must use Final target: none and Final content: none when not keeping memory` };
+    }
+    if ((decision === "keep-in-memory" && durableDocDisposition !== "memory")
+        || (decision === "keep-memory-reference" && durableDocDisposition !== "memory-reference")
+        || (decision === "move-to-durable-doc" && durableDocDisposition !== "durable-doc")) {
+        return { error: `Proposal Decision ${candidate.id} has inconsistent Decision and Durable doc disposition values` };
+    }
+    if ((durableDocDisposition === "memory" && durableDocPath !== "none")
+        || (durableDocDisposition !== "memory" && durableDocPath === "none")) {
+        return { error: `Proposal Decision ${candidate.id} must use Durable doc path: none only with Durable doc disposition: memory` };
+    }
+    return {
+        decision: {
+            candidateId: candidate.id,
+            source: match[1],
+            operation: match[2],
+            target: match[3],
+            candidate: match[4],
+            decision,
+            finalTarget,
+            whyMemoryIsNecessary: match[7],
+            impactIfAbsent: match[8],
+            durableDocDisposition,
+            durableDocAnalysis: match[10],
+            durableDocPath,
+            evidenceChecked: match[12],
+            finalContent
+        }
+    };
+}
 function validateExistingMemoryDecisions(content, hasExistingMemory) {
     const body = content.trim();
     if (body === "none") {
@@ -92,3 +267,20 @@ function extractReportSubsection(content, heading, nextHeading) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function memorySetContains(memory, value) {
+    return Object.values(memory).some((content) => memoryLines(content).has(value));
+}
+function memoryLines(content) {
+    return new Set(content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean));
+}
+function isUnresolvedReviewText(value) {
+    const normalized = value.trim().toLowerCase();
+    return (/[<>]/.test(value)
+        || normalized === "none"
+        || normalized === "tbd"
+        || normalized === "unknown"
+        || normalized === "n/a");
+}

package/dist/backend/templates/handoff.js

@@ -1,4 +1,4 @@
-import { ARCHITECTURE_BRIEF_STATUSES, ARCHITECTURE_PLAN_RESULTS, DOCS_SYNC_DECISIONS, FINAL_ACCEPTANCE_DECISIONS, L3_ACTIONS, L3_REQUIRED_VALUES, STRICT_NONE_VALUE, TEST_RESULTS, renderArtifactOptions } from "../../shared/validation/artifact-contract.js";
+import { ARCHITECTURE_BRIEF_STATUSES, ARCHITECTURE_PLAN_RESULTS, DOCS_SYNC_DECISIONS, FINAL_ACCEPTANCE_DECISIONS, L3_ACTIONS, L3_REQUIRED_VALUES, STRICT_NONE_VALUE, TEST_INFRASTRUCTURE_STATUSES, TEST_RESULTS, renderArtifactOptions } from "../../shared/validation/artifact-contract.js";
 export function renderArchitectureBriefTemplate(taskSlug) {
     return `# Architecture Brief: ${taskSlug}
 
@@ -201,6 +201,26 @@ TBD
 
 TBD
 
+## Test Infrastructure
+
+Status: ${renderArtifactOptions(TEST_INFRASTRUCTURE_STATUSES)}
+
+### Affected Files
+
+${STRICT_NONE_VALUE}
+
+### Boundary Evidence
+
+${STRICT_NONE_VALUE}
+
+### Defect-Class Sweep
+
+${STRICT_NONE_VALUE}
+
+### Repair Commit
+
+${STRICT_NONE_VALUE}
+
 ## Failed Expectations
 
 ${STRICT_NONE_VALUE}

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

@@ -185,6 +185,14 @@ when they are relevant to the changed behavior. Check that tests were not
 weakened, over-mocked, tied only to fixture values or implementation details,
 or made green by bypassing the real behavior path.
 
+Inspect the \`Test Infrastructure\` section of \`test-report.md\`. A report with
+\`repair-required\` or \`production-change-required\` is not gate-ready. When
+status is \`repaired\`, verify the affected files remain Tester-owned, the
+boundary evidence excludes production or shared changes, the defect-class sweep
+covers the affected test-infrastructure family, the repair commit exists in the
+current range, and required clean-state validation was rerun. Request changes
+for missing, contradictory, incomplete, weakened, or unverified repair evidence.
+
 Do not approve only because \`Test Result: pass\` or all recorded commands are
 green. Request changes when the report is incomplete or inconsistent with the
 actual tests, validation level does not match risk, an important behavior has
@@ -239,6 +247,13 @@ scaffold, and coder completion evidence. Verify that the complete planned
 behavior is implemented without changing architect-owned boundaries or
 contracts.
 
+When the range contains Tester-authored changes recorded in \`test-report.md\`,
+review those tests, fixtures, test-only helpers, and \`docs/TESTING.md\` against
+the Tester role, the repair or coverage evidence, and
+\`docs/CODING_STANDARDS.md\`. Do not reject a valid Tester-owned change merely
+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
 root cause is supported by the code, the implementation fixes that cause rather
@@ -319,6 +334,7 @@ Use this findings structure:
 - Boundary And Failure Coverage:
 - Public Contract Coverage:
 - Test Integrity:
+- Test Infrastructure:
 - Skips And Gaps:
 - User Approval And Gap Disposition:
 - Validation Readiness:
@@ -344,6 +360,8 @@ Use this findings structure:
 <!-- File and Line Or Symbol are required for code-diff findings. -->
 - File:
 - Line Or Symbol:
+<!-- Finding Scope is required for code-diff findings. Use test-only only when correction needs no production, runtime, public-contract, dependency, generated-context, architecture, or shared-production change. -->
+- Finding Scope: test-only|implementation
 - Evidence:
 - Expected:
 - Gap:
@@ -382,6 +400,7 @@ If there are no findings, write:
 - Boundary And Failure Coverage:
 - Public Contract Coverage:
 - Test Integrity:
+- Test Infrastructure:
 - Skips And Gaps:
 - User Approval And Gap Disposition:
 - Validation Readiness:

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

@@ -77,14 +77,17 @@ You are not part of the task workflow round state.
   even when every proposal says \`no-change\`.
 - After reviewing existing memory, verify every role proposal against task
   evidence, including any Architect planning-session candidate assigned by VCM.
-  Independently verify the stated need, absence impact, and durable-document
-  disposition. Treat every candidate as a proposal rather than authority, merge
+  Review every proposal item separately; never accept or reject an entire role
+  draft as one decision. For every Add or Update candidate, independently state
+  why the memory is necessary, what fails if it is absent, and why memory or a
+  durable document is the correct destination. Do not copy the proposer rationale
+  as the review. Treat every candidate as a proposal rather than authority, merge
   duplicates, remove stale entries, and keep role-specific knowledge in the
   matching role memory output.
 - Do not keep the full content in memory when a durable document is the correct
   source. Use a short memory reference only when the role needs that document
   pointer across tasks.
-- Record every proposal disposition and the retained, updated, and removed
+- Record every proposal decision and the retained, updated, and removed
   existing-memory decisions and summary in the exact Memory Review report block
   assigned by VCM.
 - Do not record task narrative, temporary state, unverified conclusions, or

package/dist/backend/templates/harness/project-manager-agent.js

@@ -93,9 +93,11 @@ PM may leave this path only through the allowed branches below.
 - **Coder Continuation:** If Coder returns \`Decision: incomplete\`, lacks the required completion artifact, or has not completed implementation and L0/L1 validation, route Coder again — this is the only route for an in-progress sweep. Problems recorded inside an incomplete report are sweep state, not routable failures; PM routes problems onward only from a post-sweep \`failed\` report carrying the consolidated per-item disposition.
 - **Coder Failure Debug:** If Coder returns \`Decision: failed\` with compile, typecheck, or L0/L1 failure evidence after implementation, suspend the main flow and enter Architect Debug Branch.
 - **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation. Do not enter Debug, Diagnosis, or validation-adequacy Gate Review.
-- **Tester Failure:** If Tester returns \`Test Result: fail\` for the original Coder implementation, enter Architect Debug Branch.
-- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the report to Tester, then rerun the validation-adequacy Gate after Tester updates the tests or test report.
-- **Code-Diff Correction:** If the code-diff Gate returns \`request_changes\`, suspend the main flow and enter Architect Debug Branch with the Gate report.
+- **Tester Test-Infrastructure Repair:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: repair-required\`, route Tester to repair and commit the confined test-infrastructure defect, rerun required validation, and replace \`test-report.md\`. Do not enter Architect Debug while this Tester-owned repair remains available.
+- **Tester Failure:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: none\`, \`repaired\`, or \`production-change-required\`, suspend the main flow and enter Architect Debug Branch.
+- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the complete report to Tester. Tester must correct the tests or evidence, rerun required validation, commit tracked Tester-owned changes, and replace \`test-report.md\` before PM reruns the Gate. If corrected validation returns \`fail\`, apply Tester Test-Infrastructure Repair or Tester Failure from that result.
+- **Tester Code-Diff Correction:** If every code-diff finding has \`Finding Scope: test-only\`, route the complete report to Tester. After correction, repeat Tester validation, validation-adequacy Gate, and \`code-diff --source coder\`.
+- **Code-Diff Correction:** If any code-diff finding has \`Finding Scope: implementation\`, suspend the main flow and enter Architect Debug Branch with the complete Gate report.
 - **Docs Sync Correction:** \`Decision: synced\` or \`unchanged\` continues to Final Acceptance. \`Decision: blocked\` remains at docs sync unless the report identifies an allowed Debug, Diagnosis, or user-decision branch.
 - **Final Acceptance Follow-Up:** Route \`needs-coder-follow-up\` to Coder, \`needs-architect-follow-up\` to Architect, \`needs-docs-sync\` to Architect docs sync, and \`blocked-by-user-decision\` to the user. After follow-up work, resume from the earliest affected Code-Change Flow step and repeat every downstream Gate.
 - **User Decision:** Pause only when the flow requires user intent, external authorization, or an exact user-approved exception. Resume from the suspended step after the user's decision is recorded.
@@ -116,7 +118,7 @@ The flow completes only when Final Acceptance returns:
 - Route user-originated or flow-required architecture, scope, contract, dependency, public surface, durable docs, and implementation-plan questions to Architect.
 - Do not treat Coder architecture doubts, design concerns, scaffold objections, or validation predictions as architecture questions.
 - Route validation strategy, test coverage, test-report, and validation adequacy questions to Tester.
-- Route bugs, build/runtime errors, and failing validation from a code-delivery flow to Architect Debug Mode according to the active flow. Do not route a Validation-Only Flow \`Test Result: fail\` to Debug unless the accepted outcome requires implementation repair.
+- Route bugs, build/runtime errors, and production-implementation validation failures from a code-delivery flow to Architect Debug Mode according to the active flow. Route a confined \`repair-required\` test-infrastructure failure back to Tester. Do not route a Validation-Only Flow \`Test Result: fail\` to Debug unless the accepted outcome requires implementation repair.
 - Ask the user only when user intent, priority, approval, external authorization, secrets, real cost, production permission, sensitive data access, or durable-doc conflict requires user decision.
 - Non-PM role results, blockers, findings, and requests must come back to PM. PM decides the next route.
 - Only PM decides the next VCM route, gate, pause, retry, final acceptance, or PR-Preparation Flow step. Non-PM role messages are evidence and status only; any requested next action from a non-PM role is advisory and must be reclassified by PM against the active flow, required artifacts, gate state, and PM routing rules.
@@ -134,6 +136,7 @@ Every branch must end in exactly one of these outcomes:
 
 - return to the recorded main-flow resume point
 - repeat the current responsible role
+- route to Tester for an explicitly allowed test-only repair or correction
 - route to Architect Debug Mode
 - route to Architecture Diagnosis Mode
 - pause for user decision
@@ -152,9 +155,11 @@ The shared path is:
 
 - **Normal Plan Required:** If Architect returns \`normal architecture plan required\`, enter Code-Change Flow at Architect planning. When Debug is a branch of Code-Change Flow, resume that parent flow at Architect planning.
 - **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation.
-- **Architecture Diagnosis:** If Tester returns \`Test Result: fail\`, enter Architecture Diagnosis Branch.
-- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the report to Tester, then rerun the validation-adequacy Gate after Tester updates the tests or test report.
-- **Code-Diff Revision:** If the code-diff Gate returns \`request_changes\`, route the report to Architect Debug Mode. After correction, repeat Tester validation, validation-adequacy Gate, and \`code-diff --source architect-debug\`.
+- **Tester Test-Infrastructure Repair:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: repair-required\`, route Tester to repair and commit the confined test-infrastructure defect, rerun required validation, and replace \`test-report.md\`.
+- **Architecture Diagnosis:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: none\`, \`repaired\`, or \`production-change-required\`, enter Architecture Diagnosis Branch.
+- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the complete report to Tester. After Tester corrects tests or evidence, reruns validation, commits tracked Tester-owned changes, and replaces \`test-report.md\`, rerun the Gate.
+- **Tester Code-Diff Correction:** If every code-diff finding has \`Finding Scope: test-only\`, route the complete report to Tester. After correction, repeat Tester validation, validation-adequacy Gate, and \`code-diff --source architect-debug\`.
+- **Code-Diff Revision:** If any code-diff finding has \`Finding Scope: implementation\`, route the complete report to Architect Debug Mode. After correction, repeat Tester validation, validation-adequacy Gate, and \`code-diff --source architect-debug\`.
 
 #### Successful Exit
 
@@ -183,9 +188,11 @@ Architecture Diagnosis Mode must run before another Debug Mode fix or Coder disp
 #### Allowed Branches
 
 - **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation.
-- **Tester Failure:** If Tester returns \`Test Result: fail\` for the Diagnosis implementation, pause and report to the user. If required validation remains unavailable, ask whether the user explicitly approves retaining that exact Coverage Gap.
-- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the report to Tester, then rerun the validation-adequacy Gate after Tester updates the tests or test report.
-- **Code-Diff Revision:** If the code-diff Gate returns \`request_changes\`, route the report to Architecture Diagnosis Mode. After correction, repeat Tester validation, validation-adequacy Gate, and \`code-diff --source architect-diagnosis\`.
+- **Tester Test-Infrastructure Repair:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: repair-required\`, route Tester to repair and commit the confined test-infrastructure defect, rerun required validation, and replace \`test-report.md\`.
+- **Tester Failure:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: none\`, \`repaired\`, or \`production-change-required\`, pause and report to the user. If required validation remains unavailable, ask whether the user explicitly approves retaining that exact Coverage Gap.
+- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the complete report to Tester. After Tester corrects tests or evidence, reruns validation, commits tracked Tester-owned changes, and replaces \`test-report.md\`, rerun the Gate.
+- **Tester Code-Diff Correction:** If every code-diff finding has \`Finding Scope: test-only\`, route the complete report to Tester. After correction, repeat Tester validation, validation-adequacy Gate, and \`code-diff --source architect-diagnosis\`.
+- **Code-Diff Revision:** If any code-diff finding has \`Finding Scope: implementation\`, route the complete report to Architecture Diagnosis Mode. After correction, repeat Tester validation, validation-adequacy Gate, and \`code-diff --source architect-diagnosis\`.
 
 #### Successful Exit
 
@@ -258,7 +265,8 @@ PM may leave this path only through the allowed branches below.
 #### Allowed Branches
 
 - **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation.
-- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the report to Tester and rerun the Gate after correction.
+- **Tester Test-Infrastructure Repair:** If Tester returns \`Test Result: fail\` with \`Test Infrastructure Status: repair-required\`, route Tester to repair and commit the confined defect, rerun required validation, and replace \`test-report.md\`.
+- **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the complete report to Tester and rerun the Gate after Tester corrects tests or evidence, reruns validation, commits tracked Tester-owned changes, and replaces \`test-report.md\`.
 - **Code Change Required:** If the accepted outcome requires production-code, runtime-behavior, public-contract, dependency, or system-architecture changes, enter Code-Change Flow at Architect planning.
 - **User Decision:** If validation requires missing user intent, credentials, environment access, sensitive data, real cost, or external authorization, pause and ask the user.
 
@@ -335,11 +343,11 @@ PM may lightly rewrite the user's words to:
 
 - Gate Review requests are mandatory and unconditional. At every trigger point, use the \`vcm-gate-review\` skill to run \`.ai/tools/request-gate-review\` with the matching gate and code source arguments without first judging whether Gate Review is enabled. The tool (via VCM) is the single source of truth for enable state; never skip the run because you assume Gate Review is off or because the worktree has no gate-review index yet.
 - The tool's first output line decides the next step: \`disabled\`, \`not_required\`, or \`already_approved\` continue the normal VCM flow; \`started\` or \`running\` stop the turn and wait for the VCM callback; \`failed_to_start\` is a hard stop — report it to the user and do not silently proceed past the gate.
-- Trigger points (run each unconditionally): after the architecture brief is confirmed and Architect completes planning, before coder dispatch run \`architecture-plan\`; after Tester returns a terminal \`Test Result: pass|fail\` that the active flow permits to reach the gate, run \`validation-adequacy\`; after that validation-adequacy Gate completes successfully, run \`code-diff --source coder\` for Coder implementation, \`code-diff --source architect-debug\` for an Architect Debug fix, or \`code-diff --source architect-diagnosis\` for an Architecture Diagnosis fix. Validation-Only Flow stops after validation-adequacy and does not run code-diff. Never run either post-implementation Gate for \`Test Result: incomplete\`.
+- Trigger points (run each unconditionally): after the architecture brief is confirmed and Architect completes planning, before coder dispatch run \`architecture-plan\`; after Tester returns a terminal \`Test Result: pass|fail\` that the active flow permits to reach the gate, run \`validation-adequacy\`; after that validation-adequacy Gate completes successfully, run \`code-diff --source coder\` for Coder implementation, \`code-diff --source architect-debug\` for an Architect Debug fix, or \`code-diff --source architect-diagnosis\` for an Architecture Diagnosis fix. A test report with \`Test Infrastructure Status: repair-required\` or \`production-change-required\` does not reach a Gate; route the matching allowed branch first. Validation-Only Flow stops after validation-adequacy and does not run code-diff. Never run either post-implementation Gate for \`Test Result: incomplete\`.
 - PM does not inspect commits or decide whether code changes exist. At a \`code-diff\` trigger point, run the tool; the tool decides \`disabled\`, \`not_required\`, \`already_approved\`, or starts review.
 - Do not run \`code-diff\` before Tester completes, while validation-adequacy is unresolved, or for incomplete, unresolved failed, planning-only, Docs-Only Flow, Validation-Only Flow, PR-Preparation Flow, or Communication-Only Flow. A terminal \`fail\` with the exact required user-approved testing gap may proceed only through the recorded validation-adequacy disposition.
 - Gate Review trigger points apply only when the active delivery flow reaches that milestone. Do not run Gate Review for Communication-Only Flow.
-- On a callback, accept only \`approve\` or \`request_changes\`. Apply \`request_changes\` through the allowed branch defined by the active flow; in Code-Change Flow use Architecture Plan Revision, Code-Diff Correction, or Validation Revision according to the gate.
+- On a callback, accept only \`approve\` or \`request_changes\`. Apply \`request_changes\` through the allowed branch defined by the active flow; for code-diff, use Tester Code-Diff Correction only when every finding is \`test-only\`, otherwise use the flow's Architect correction branch.
 - Do not ask Reviewer to choose owners, fixes, Replan, or user-intervention needs.
 - Record gate decision, report path, and any skip or override reason.
 

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

@@ -9,7 +9,7 @@ ${renderRoleMemoryRules("tester")}
 
 - Own independent validation, tester-owned test design, test implementation, test adequacy, \`docs/TESTING.md\`, and final validation confidence.
 - Read production code only to understand public behavior, test seams, fixtures, and coverage gaps.
-- Do not edit production code, decide architecture, or diagnose fixes beyond validation evidence.
+- Do not edit production code or decide architecture. Diagnose and repair only PM-routed defects confined to Tester-owned tests, fixtures, test-only helpers, and \`docs/TESTING.md\`; otherwise report validation evidence without proposing a fix.
 
 ### Inputs
 
@@ -40,7 +40,7 @@ ${renderRoleMemoryRules("tester")}
 - If project-manager asks for clarification, clarify only the validation evidence, expected behavior, affected path, or coverage gap.
 - If validation fails or expected behavior is unclear, report the evidence to project-manager; architect owns diagnosis, and project-manager decides the next route.
 - After Architect Debug or Architecture Diagnosis changes, rerun the required validation independently. Architect validation is implementation evidence and does not replace Tester final validation.
-- Add or modify tests, test fixtures, or test-only helpers needed for validation confidence.
+- Add or modify tests, test fixtures, or test-only helpers needed for correct, reliable validation and approved behavior coverage.
 - Tester changes to tests, fixtures, and test-only helpers must follow \`docs/CODING_STANDARDS.md\` and prove the approved behavior contract.
 - Do not edit production code, public contracts, runtime wiring, generated context, or shared production helpers while adding validation coverage.
 - Do not weaken assertions, reshape fixtures to match the current implementation, bypass real behavior paths, skip tests, or add test-only shortcuts.
@@ -57,6 +57,16 @@ ${renderRoleMemoryRules("tester")}
 - A required check that fails, is skipped, or cannot be completed by Tester continuation is a blocking validation issue and requires \`Test Result: fail\`.
 - Update \`docs/TESTING.md\` when validation strategy, commands, level mapping, integration/E2E case definitions, selection rules, final-validation cleanup, test gaps, or test expectations change.
 
+### Test-Infrastructure Repair
+
+- Use this repair path only when project-manager routes a reported test-infrastructure defect back to Tester.
+- The repair must remain confined to tests, fixtures, test-only helpers, or \`docs/TESTING.md\`. It must not change production code, runtime behavior, public contracts, dependencies, generated context, system architecture, or shared production helpers.
+- Confirm the defect mechanism from current files and reproducible evidence. In the affected test-infrastructure family, inspect every occurrence of the same mechanism and repair every confirmed instance.
+- Do not replace a repair with a workaround that bypasses the defective path, weakens assertions, skips validation, or hides the failure.
+- After repair, perform the required clean-state validation again and replace \`test-report.md\` with current results.
+- If the repair requires any prohibited production or shared scope, do not make that change. Record \`Test Infrastructure Status: production-change-required\` and the concrete boundary evidence for project-manager.
+- A current validation path with an unresolved test-infrastructure defect cannot return \`Test Result: pass\`.
+
 ### Mandatory L3 End-To-End Coverage
 
 L3 validates a complete externally observable flow from a project-defined
@@ -126,7 +136,27 @@ Coverage Gap.
 
 ### Outputs
 
-- Write \`.ai/vcm/handoffs/test-report.md\` with \`Test Result: pass|fail|incomplete\`, evidence reviewed, tests added or updated, coverage mapping, validation progress, commands run or checked, validation results, failed expectations, reproduction steps, skipped checks with reasons, coverage gaps, blocking validation issues, and user approval evidence.
+- Write \`.ai/vcm/handoffs/test-report.md\` with \`Test Result: pass|fail|incomplete\`, evidence reviewed, tests added or updated, coverage mapping, validation progress, commands run or checked, validation results, test-infrastructure status and evidence, failed expectations, reproduction steps, skipped checks with reasons, coverage gaps, blocking validation issues, and user approval evidence.
+- \`test-report.md\` must include this test-infrastructure section:
+
+\`\`\`md
+## Test Infrastructure
+
+Status: none|repair-required|repaired|production-change-required
+
+### Affected Files
+
+### Boundary Evidence
+
+### Defect-Class Sweep
+
+### Repair Commit
+\`\`\`
+
+- Use \`none\` when no test-infrastructure defect was found. Every subsection must then be exactly \`None.\`.
+- Use \`repair-required\` only for a confirmed defect confined to Tester-owned scope that project-manager must route back to Tester. Record affected files, boundary evidence, and the completed defect-class sweep; set Repair Commit to exactly \`None.\` and return \`Test Result: fail\`.
+- Use \`repaired\` after the PM-routed repair is committed and required validation is rerun. Record affected files, boundary evidence, defect-class sweep, and the repair commit.
+- Use \`production-change-required\` when repair requires production or shared scope. Record affected files, boundary evidence, and the completed defect-class sweep; set Repair Commit to exactly \`None.\` and return \`Test Result: fail\`.
 - \`test-report.md\` must include this L3 section:
 
 \`\`\`md
@@ -148,13 +178,14 @@ L3 Required: yes|no
 
 - When \`L3 Required: yes\`, include at least one complete flow-to-case mapping. \`Action\` must be \`run-existing\`, \`updated\`, or \`added\`.
 - When \`L3 Required: no\`, use \`Not-Required Evidence\` to prove every condition in the L3 not-required rule.
-- In Validation-Only Flow, if tests, fixtures, test-only helpers, or \`docs/TESTING.md\` changed, commit those changes before reporting and record the changed files and commit in \`test-report.md\`. If no tracked files changed, record that no commit was required.
+- In every flow, if tests, fixtures, test-only helpers, or \`docs/TESTING.md\` changed, commit those changes before reporting a terminal result and record the changed files and commit in \`test-report.md\`. If no tracked files changed, record that no commit was required.
 - \`test-report.md\` is the current validation evidence, not a log; when rewriting it, carry forward still-unresolved findings or explicitly mark them resolved instead of dropping them.
 - In \`Coverage Mapping\`, map each accepted changed behavior or relevant risk to its validation level, actual test file and case or external evidence, exercised entry path and key assertions, result, and any remaining gap.
 - In \`Validation Progress\`, record \`Completed Validation\` and \`Remaining Validation\`. A final \`pass\` report must set remaining validation to \`None\`.
 - Use \`pass\` only when required validation completed and no blocking test failure, missing required coverage, unacceptable test weakness, or unresolved validation risk remains.
 - Use \`fail\` only when tests fail, coverage is insufficient and Tester continuation cannot resolve it, required validation is blocked from completion, test quality is unacceptable, or validation risk needs project-manager routing.
 - Use \`incomplete\` only when required validation remains, no blocking issue has been found, and another Tester turn can continue the recorded remaining work.
+- \`Test Infrastructure Status: repair-required\` or \`production-change-required\` requires \`Test Result: fail\`; neither status may appear in a \`pass\` or \`incomplete\` report.
 - When \`Test Result: pass\`, the entire body of \`Remaining Validation\`, \`Failed Expectations\`, \`Coverage Gaps\`, \`Blocking Validation Issues\`, and \`User Approval Evidence\` must be exactly \`None.\` with no additional text.
 - When \`Test Result: incomplete\`, \`Completed Validation\` and \`Remaining Validation\` must both contain concrete progress, while the entire body of \`Failed Expectations\`, \`Coverage Gaps\`, \`Blocking Validation Issues\`, and \`User Approval Evidence\` must be exactly \`None.\` with no additional text.
 - When \`Test Result: fail\`, \`Blocking Validation Issues\` must list concrete blocking evidence.

package/dist/shared/types/gate-review.js

@@ -3,6 +3,10 @@ export const GATE_REVIEW_GATES = [
     "validation-adequacy",
     "code-diff"
 ];
+export const CODE_DIFF_FINDING_SCOPES = [
+    "test-only",
+    "implementation"
+];
 export const CODE_DIFF_SOURCES = [
     "coder",
     "architect-debug",

package/dist/shared/validation/artifact-check.js

@@ -1,4 +1,4 @@
-import { ARCHITECTURE_BRIEF_STATUSES, ARCHITECTURE_PLAN_RESULTS, DOCS_SYNC_DECISIONS, FINAL_ACCEPTANCE_DECISIONS, L3_ACTIONS, L3_REQUIRED_VALUES, STRICT_NONE_VALUE, TEST_RESULTS } from "./artifact-contract.js";
+import { ARCHITECTURE_BRIEF_STATUSES, ARCHITECTURE_PLAN_RESULTS, DOCS_SYNC_DECISIONS, FINAL_ACCEPTANCE_DECISIONS, L3_ACTIONS, L3_REQUIRED_VALUES, STRICT_NONE_VALUE, TEST_INFRASTRUCTURE_STATUSES, TEST_RESULTS } from "./artifact-contract.js";
 const REQUIRED_HEADINGS = {
     "architecture-brief": [
         "Accepted Outcome",
@@ -50,6 +50,11 @@ const REQUIRED_HEADINGS = {
         "Not-Required Evidence",
         "Commands Run Or Checked",
         "Validation Results",
+        "Test Infrastructure",
+        "Affected Files",
+        "Boundary Evidence",
+        "Defect-Class Sweep",
+        "Repair Commit",
         "Failed Expectations",
         "Reproduction Steps",
         "Skipped Checks With Reasons",
@@ -152,6 +157,55 @@ function validateArtifactFields(kind, content) {
         const invalidFields = isAllowedValue(result, TEST_RESULTS)
             ? []
             : [renderExactFieldError("Test Result", TEST_RESULTS, result)];
+        const infrastructureStatus = readInlineField(readArtifactSectionContent(content, "Test Infrastructure") ?? "", "Status");
+        if (!isAllowedValue(infrastructureStatus, TEST_INFRASTRUCTURE_STATUSES)) {
+            invalidFields.push(renderExactFieldError("Test Infrastructure Status", TEST_INFRASTRUCTURE_STATUSES, infrastructureStatus));
+        }
+        const infrastructureFiles = readArtifactSectionContent(content, "Affected Files");
+        const infrastructureBoundary = readArtifactSectionContent(content, "Boundary Evidence");
+        const infrastructureSweep = readArtifactSectionContent(content, "Defect-Class Sweep");
+        const infrastructureCommit = readArtifactSectionContent(content, "Repair Commit");
+        if (infrastructureStatus === "none") {
+            for (const [heading, value] of [
+                ["Affected Files", infrastructureFiles],
+                ["Boundary Evidence", infrastructureBoundary],
+                ["Defect-Class Sweep", infrastructureSweep],
+                ["Repair Commit", infrastructureCommit]
+            ]) {
+                if (!isExactNone(value)) {
+                    invalidFields.push(renderExactSectionError(heading, STRICT_NONE_VALUE, value, "when Test Infrastructure Status is none"));
+                }
+            }
+        }
+        if (infrastructureStatus === "repair-required" || infrastructureStatus === "production-change-required") {
+            for (const [heading, value] of [
+                ["Affected Files", infrastructureFiles],
+                ["Boundary Evidence", infrastructureBoundary],
+                ["Defect-Class Sweep", infrastructureSweep]
+            ]) {
+                if (!hasSubstantiveSectionValue(value)) {
+                    invalidFields.push(`${heading} is required when Test Infrastructure Status is ${infrastructureStatus}.`);
+                }
+            }
+            if (!isExactNone(infrastructureCommit)) {
+                invalidFields.push(renderExactSectionError("Repair Commit", STRICT_NONE_VALUE, infrastructureCommit, `when Test Infrastructure Status is ${infrastructureStatus}`));
+            }
+            if (result !== "fail") {
+                invalidFields.push(`Test Result must be fail when Test Infrastructure Status is ${infrastructureStatus}.`);
+            }
+        }
+        if (infrastructureStatus === "repaired") {
+            for (const [heading, value] of [
+                ["Affected Files", infrastructureFiles],
+                ["Boundary Evidence", infrastructureBoundary],
+                ["Defect-Class Sweep", infrastructureSweep],
+                ["Repair Commit", infrastructureCommit]
+            ]) {
+                if (!hasSubstantiveSectionValue(value)) {
+                    invalidFields.push(`${heading} is required when Test Infrastructure Status is repaired.`);
+                }
+            }
+        }
         const l3Required = readInlineField(content, "L3 Required");
         if (!isAllowedValue(l3Required, L3_REQUIRED_VALUES)) {
             invalidFields.push(renderExactFieldError("L3 Required", L3_REQUIRED_VALUES, l3Required));

package/dist/shared/validation/artifact-contract.js

@@ -6,6 +6,12 @@ export const ARCHITECTURE_PLAN_RESULTS = [
     "user clarification required"
 ];
 export const TEST_RESULTS = ["pass", "fail", "incomplete"];
+export const TEST_INFRASTRUCTURE_STATUSES = [
+    "none",
+    "repair-required",
+    "repaired",
+    "production-change-required"
+];
 export const L3_REQUIRED_VALUES = ["yes", "no"];
 export const L3_ACTIONS = ["run-existing", "updated", "added"];
 export const DOCS_SYNC_DECISIONS = ["synced", "unchanged", "blocked"];

package/package.json

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