vibe-coding-master 0.7.29 → 0.7.30

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

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

package/dist/backend/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

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

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

@@ -82,7 +82,7 @@ Use this flow when the accepted task requires production-code or runtime-behavio
 
 The main flow is:
 
-\`Architect Interview and planning -> architecture-plan Gate -> Coder implementation -> code-diff Gate -> Tester validation -> validation-adequacy Gate -> Architect docs sync -> Final Acceptance -> completed\`
+\`Architect Interview and planning -> architecture-plan Gate -> Coder implementation -> Tester validation -> validation-adequacy Gate -> code-diff Gate -> Architect docs sync -> Final Acceptance -> completed\`
 
 PM may leave this path only through the allowed branches below.
 
@@ -92,10 +92,10 @@ PM may leave this path only through the allowed branches below.
 - **Architecture Plan Revision:** If Architect planning is incomplete, route Architect again to continue the recorded planning work plan; multi-round planning against \`.ai/vcm/handoffs/planning-progress.md\` is the normal path for large plans, and PM must not press for completion within one round or accept summary-row compression in place of remaining steps. If the architecture-plan Gate returns \`request_changes\`, route the complete report to Architect, then rerun the full architecture-plan Gate after the plan and scaffold are revised.
 - **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.
-- **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 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.
 - **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.
@@ -146,19 +146,20 @@ Use Architect Debug Branch when another active flow is suspended to correct impl
 
 The shared path is:
 
-\`Architect Debug Mode -> code-diff --source architect-debug -> Tester\`
+\`Architect Debug Mode -> Tester -> validation-adequacy Gate -> code-diff --source architect-debug\`
 
 #### Allowed Branches
 
 - **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.
-- **Code-Diff Revision:** If the code-diff Gate returns \`request_changes\`, route the report to Architect Debug Mode and rerun \`code-diff --source architect-debug\` after correction.
 - **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\`.
 
 #### Successful Exit
 
-- For Architect Debug Flow, Tester pass continues to \`validation-adequacy Gate -> Architect docs sync -> Final Acceptance\`.
-- For Architect Debug Branch, Tester pass returns to the recorded parent-flow resume point. The branch does not run its own docs sync or Final Acceptance.
+- For Architect Debug Flow, code-diff approval continues to \`Architect docs sync -> Final Acceptance\`.
+- For Architect Debug Branch, code-diff approval returns to the recorded parent-flow resume point after the parent flow's validation and code-diff milestones. The branch does not run its own docs sync or Final Acceptance.
 
 Architect Debug Flow or Branch never routes implementation to Coder. Architect executes Architect Debug Mode; PM owns whether the current context is a Flow or Branch and where it continues afterward.
 
@@ -175,22 +176,23 @@ Record the parent flow and resume point before entering the branch.
 
 The code-delivery path is:
 
-\`Architecture Diagnosis Mode -> code-diff --source architect-diagnosis -> Tester\`
+\`Architecture Diagnosis Mode -> Tester -> validation-adequacy Gate -> code-diff --source architect-diagnosis\`
 
 Architecture Diagnosis Mode must run before another Debug Mode fix or Coder dispatch. Architect owns diagnosis, implementation, validation, and commit completion. Do not route Diagnosis implementation to Coder.
 
 #### Allowed Branches
 
-- **Code-Diff Revision:** If the code-diff Gate returns \`request_changes\`, route the report to Architecture Diagnosis Mode and rerun \`code-diff --source architect-diagnosis\` after correction.
 - **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\`.
 
 #### Successful Exit
 
 - An analysis-only Architecture Diagnosis Flow completes from the diagnosis result.
 - An analysis-only Architecture Diagnosis Branch returns to the recorded parent-flow resume point.
-- A code-producing Architecture Diagnosis Flow continues after Tester pass to \`validation-adequacy Gate -> Architect docs sync -> Final Acceptance\`.
-- A code-producing Architecture Diagnosis Branch returns after Tester pass to the recorded parent-flow resume point. It does not run its own docs sync or Final Acceptance.
+- A code-producing Architecture Diagnosis Flow continues after code-diff approval to \`Architect docs sync -> Final Acceptance\`.
+- A code-producing Architecture Diagnosis Branch returns after code-diff approval to the recorded parent-flow resume point after the parent flow's validation and code-diff milestones. It does not run its own docs sync or Final Acceptance.
 
 After Tester Failure, PM should summarize:
 
@@ -327,15 +329,15 @@ PM may lightly rewrite the user's words to:
 - A Tester \`Test Result: incomplete\` is continuation state, not failure evidence. Route Tester again and do not run validation-adequacy Gate Review or Final Acceptance from it.
 - The Architect does not begin planning until \`architecture-brief.md\` is confirmed (this happens inside the same Architect Interview-and-planning turn, not a separate PM route). Advance to the next gate only when the required role artifact/result is complete and PM routing rules allow that gate.
 - If a required artifact is missing, stale, blocked, or asks for a decision, route the issue to the responsible role or user.
-- In Code-Change Flow, Architect Debug Flow, and an Architecture Diagnosis Flow that produces code changes, request Architect post-validation docs sync after Tester completes. Architect Debug Branch and Architecture Diagnosis Branch return to their recorded resume points after Tester passes.
+- In Code-Change Flow, Architect Debug Flow, and an Architecture Diagnosis Flow that produces code changes, request Architect post-validation docs sync only after Tester validation, validation-adequacy Gate, and code-diff Gate complete. Architect Debug Branch and Architecture Diagnosis Branch return to their recorded resume points only after those same milestones complete.
 
 ### Gate Review Gates
 
 - 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, before post-validation docs sync or final acceptance in a code-delivery flow, or before Validation-Only Flow completion, run \`validation-adequacy\`; after any Coder \`Decision: ready_for_review\` result run \`code-diff --source coder\`; after any Architect Debug Mode completed code fix run \`code-diff --source architect-debug\`; after any Architecture Diagnosis Mode completed code fix run \`code-diff --source architect-diagnosis\`. Never run validation-adequacy for \`Test Result: incomplete\`. Run code-diff before routing to Tester.
+- 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\`.
 - 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\` for incomplete, failed, planning-only, Docs-Only Flow, Validation-Only Flow, PR-Preparation Flow, or Communication-Only Flow.
+- 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.
 - Do not ask Reviewer to choose owners, fixes, Replan, or user-intervention needs.

package/dist/backend/templates/harness/restart-architect-skill.js

@@ -9,12 +9,16 @@ Run:
 .ai/tools/request-architect-restart
 \`\`\`
 
-If VCM reports \`scheduled\` with a non-empty \`memoryCandidatePath\`, use
-\`vcm-propose-memory\` to write a planning-session memory candidate to that exact
-path before writing the completed route. This candidate is provisional input for
-the later Auto Memory review; it does not edit active memory.
+If VCM reports \`scheduled\` with a non-empty \`memoryCandidatePath\`, ensure
+that one planning-session memory candidate exists at that exact path before
+writing the completed route. Use \`vcm-propose-memory\` to create it when it is
+absent. The candidate is a task-level provisional input for the later Auto
+Memory review; it does not edit active memory.
 
-Then write the completed Architect-to-PM route message and end the turn. VCM keeps the current Architect session through any architecture-plan Gate revision rounds and restarts it only after the route is accepted by PM and that Gate is approved or explicitly excepted.
+If VCM reports \`already_scheduled\`, keep the existing candidate and pending
+restart. Do not recreate either one.
+
+Then write the completed Architect-to-PM route message and end the turn. VCM keeps the current Architect session and the same pending restart through any architecture-plan Gate revision rounds, then restarts it only after the latest route is accepted by PM and that Gate is approved or explicitly excepted.
 
 Do not use this skill for incomplete planning, user clarification, Debug Mode, Architecture Diagnosis Mode, or docs sync.`;
 }

package/dist/shared/types/architect-restart.js

@@ -0,0 +1 @@
+export {};