vibe-coding-master 0.7.29 → 0.7.31

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

@@ -70,7 +70,8 @@ export function registerTaskRoutes(app, deps) {
                 messages,
                 orchestration,
                 roundState,
-                workflowState
+                workflowState,
+                architectRestart: deps.architectRestartService.getState(project.repoRoot, taskSlug)
             };
         }
         catch (error) {
@@ -84,7 +85,8 @@ export function registerTaskRoutes(app, deps) {
                         updatedAt: new Date().toISOString()
                     },
                     roundState: degradedRoundState(taskSlug),
-                    workflowState: degradedWorkflowState(taskSlug)
+                    workflowState: degradedWorkflowState(taskSlug),
+                    architectRestart: deps.architectRestartService.getState(repoRoot, taskSlug)
                 };
             }
             throw error;

package/dist/backend/server.js

@@ -130,7 +130,8 @@ export async function createServer(deps, options = {}) {
         messageService: deps.messageService,
         taskLaunchService: deps.taskLaunchService,
         roundService: deps.roundService,
-        taskWorkflowService: deps.taskWorkflowService
+        taskWorkflowService: deps.taskWorkflowService,
+        architectRestartService: deps.architectRestartService
     });
     registerSessionRoutes(app, {
         projectService: deps.projectService,

package/dist/backend/services/architect-restart-service.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { resolveRepoPath } from "../adapters/filesystem.js";
-import { VcmError } from "../errors.js";
+import { toVcmError, VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH } from "./memory-review-paths.js";
 import { validateMemoryProposal } from "./memory-proposal-validation.js";
@@ -23,40 +23,41 @@ export function createArchitectRestartService(deps) {
         async schedule(repoRoot, taskSlug) {
             const session = await requireRunningArchitect(repoRoot, taskSlug);
             await requireCompletePlan(repoRoot, taskSlug);
-            const memoryCandidatePath = (await deps.appSettings.getPreferences()).autoMemoryEnabled
-                ? ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH
-                : undefined;
-            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
-            const candidatePath = resolveRepoPath(getTaskRuntimeRepoRoot(task), ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH);
-            if (deps.fs.removePath) {
-                await deps.fs.removePath(candidatePath, { force: true });
-            }
-            else if (await deps.fs.pathExists(candidatePath)) {
-                await deps.fs.writeText(candidatePath, "");
-            }
             const key = taskKey(repoRoot, taskSlug);
             const existing = pendingByTask.get(key);
             if (existing?.sessionId === session.id) {
-                existing.stopped = false;
-                existing.deliveredMessageId = undefined;
-                existing.acceptedMessageId = undefined;
-                existing.gateAccepted = false;
-                existing.executing = false;
-                existing.memoryCandidatePath = memoryCandidatePath;
+                if (existing.status === "blocked") {
+                    existing.status = "pending";
+                    existing.blocker = undefined;
+                    await tryRestart(existing);
+                    return {
+                        taskSlug,
+                        sessionId: session.id,
+                        status: "scheduled",
+                        ...(existing.memoryCandidatePath
+                            ? { memoryCandidatePath: existing.memoryCandidatePath }
+                            : {})
+                    };
+                }
                 return {
                     taskSlug,
                     sessionId: session.id,
-                    status: "scheduled",
-                    ...(memoryCandidatePath ? { memoryCandidatePath } : {})
+                    status: "already_scheduled",
+                    ...(existing.memoryCandidatePath
+                        ? { memoryCandidatePath: existing.memoryCandidatePath }
+                        : {})
                 };
             }
+            const memoryCandidatePath = (await deps.appSettings.getPreferences()).autoMemoryEnabled
+                ? ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH
+                : undefined;
             pendingByTask.set(key, {
                 repoRoot,
                 taskSlug,
                 sessionId: session.id,
                 stopped: false,
                 gateAccepted: false,
-                executing: false,
+                status: "pending",
                 memoryCandidatePath
             });
             return {
@@ -66,9 +67,24 @@ export function createArchitectRestartService(deps) {
                 ...(memoryCandidatePath ? { memoryCandidatePath } : {})
             };
         },
+        getState(repoRoot, taskSlug) {
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending) {
+                return null;
+            }
+            return {
+                taskSlug: pending.taskSlug,
+                sessionId: pending.sessionId,
+                status: pending.status,
+                ...(pending.memoryCandidatePath
+                    ? { memoryCandidatePath: pending.memoryCandidatePath }
+                    : {}),
+                ...(pending.blocker ? { blocker: { ...pending.blocker } } : {})
+            };
+        },
         async recordArchitectStop(repoRoot, taskSlug, sessionId) {
             const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending || pending.sessionId !== sessionId) {
+            if (!pending || pending.sessionId !== sessionId || pending.status === "blocked") {
                 return;
             }
             pending.stopped = true;
@@ -79,7 +95,7 @@ export function createArchitectRestartService(deps) {
                 return;
             }
             const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending) {
+            if (!pending || pending.status === "blocked") {
                 return;
             }
             pending.deliveredMessageId = message.id;
@@ -90,7 +106,7 @@ export function createArchitectRestartService(deps) {
                 return;
             }
             const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending) {
+            if (!pending || pending.status === "blocked") {
                 return;
             }
             pending.acceptedMessageId = message.id;
@@ -98,7 +114,7 @@ export function createArchitectRestartService(deps) {
         },
         async recordArchitectureGateDisposition(repoRoot, taskSlug, accepted) {
             const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending) {
+            if (!pending || pending.status === "blocked") {
                 return;
             }
             pending.gateAccepted = accepted;
@@ -131,7 +147,7 @@ export function createArchitectRestartService(deps) {
         }
     }
     async function tryRestart(pending) {
-        if (pending.executing
+        if (pending.status !== "pending"
             || !pending.stopped
             || !pending.deliveredMessageId
             || pending.deliveredMessageId !== pending.acceptedMessageId
@@ -140,12 +156,26 @@ export function createArchitectRestartService(deps) {
         }
         const session = await deps.sessionService.getRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE);
         if (!session
-            || session.id !== pending.sessionId
-            || session.status !== "running"
-            || session.activityStatus !== "idle") {
+            || session.id !== pending.sessionId) {
+            blockPending(pending, new VcmError({
+                code: "ARCHITECT_RESTART_SESSION_UNAVAILABLE",
+                message: "Architect restart is blocked because the scheduled Architect session no longer exists.",
+                statusCode: 409
+            }));
             return;
         }
-        pending.executing = true;
+        if (session.status !== "running") {
+            blockPending(pending, new VcmError({
+                code: "ARCHITECT_RESTART_SESSION_NOT_RUNNING",
+                message: "Architect restart is blocked because the scheduled Architect session is not running.",
+                statusCode: 409
+            }));
+            return;
+        }
+        if (session.activityStatus !== "idle") {
+            return;
+        }
+        pending.status = "executing";
         try {
             await requireCompletePlan(pending.repoRoot, pending.taskSlug);
             await requirePlanningMemoryCandidate(pending);
@@ -157,10 +187,19 @@ export function createArchitectRestartService(deps) {
             });
             pendingByTask.delete(taskKey(pending.repoRoot, pending.taskSlug));
         }
-        catch {
-            pending.executing = false;
+        catch (error) {
+            blockPending(pending, error);
         }
     }
+    function blockPending(pending, error) {
+        const normalized = toVcmError(error);
+        pending.status = "blocked";
+        pending.blocker = {
+            code: normalized.code,
+            message: normalized.message,
+            blockedAt: new Date().toISOString()
+        };
+    }
     async function requirePlanningMemoryCandidate(pending) {
         if (!pending.memoryCandidatePath) {
             return;

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"
@@ -68,7 +69,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: [
@@ -88,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;
@@ -309,6 +314,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;
@@ -1031,11 +1069,39 @@ 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") {
+    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 undefined;
+}
+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;
     }
-    return `${relativePath} is incomplete and cannot start validation-adequacy review. `
-        + formatValidationArtifactFailure(check, content);
+    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";
@@ -1310,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
         });
     }
@@ -1408,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") ?? "",
@@ -1420,7 +1489,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
@@ -1467,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/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/architect-agent.js

@@ -115,9 +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.
-- If VCM returns a \`memoryCandidatePath\`, use \`vcm-propose-memory\` to write the planning-session memory candidate to that path before routing. Include only verified, durable, reusable project knowledge from planning; do not record task narrative, temporary state, unverified conclusions, or Harness rules.
-- After the required candidate is written, 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

@@ -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

@@ -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
@@ -207,10 +215,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
@@ -237,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
@@ -262,6 +279,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
@@ -312,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:
@@ -337,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:
@@ -375,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:
@@ -464,8 +490,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 +526,7 @@ import argparse
 import hashlib
 import json
 import os
+import re
 import subprocess
 import sys
 import urllib.error
@@ -528,7 +555,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 +733,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 +820,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 +941,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":