vibe-coding-master 0.7.32 → 0.7.34

package/README.md

@@ -467,8 +467,9 @@ files.
 Review Task Harness after Final Acceptance, Project Manager, Architect, Coder,
 Tester, and an enabled Reviewer submit proposals in sequence through
 `vcm-propose-memory`. Harness Engineer verifies and consolidates them before VCM
-applies the result as part of the same Task Harness Retrospective. Roles cannot
-edit active memory directly.
+records the result as part of the same Task Harness Retrospective. Workflow roles
+cannot edit active memory directly; Harness Engineer edits it only during the
+assigned Auto Memory Retrospective.
 
 When Auto Memory is enabled, the planning Architect writes a provisional memory
 candidate before its post-planning Session restart. VCM snapshots that candidate
@@ -477,11 +478,12 @@ the completed implementation and tests, and Harness Engineer reviews it with all
 final role proposals before anything becomes active memory.
 
 Shared memory is stored in the root `CLAUDE.md` `<VCM-memory>` block. Role memory
-is stored in the matching `.claude/agents/*.md` block. VCM changes only block
-contents and creates a dedicated commit in the active task worktree. Harness
-Studio shows current memory and task-local applied history. Memory is applied
-before user review; while the task worktree remains available, the user can edit
-current memory or revert a recorded change through another commit.
+is stored in the matching `.claude/agents/*.md` block. Harness Engineer changes
+only those blocks and creates a dedicated commit in the active task worktree.
+VCM verifies the mechanical commit boundary and records the after snapshot and
+diff. Harness Studio shows current memory and task-local applied history. Memory
+is applied before user review; while the task worktree remains available, the
+user can edit current memory or revert a recorded change through another commit.
 
 Post-task processing is ordered by the backend:
 
@@ -493,7 +495,8 @@ Final Acceptance
   -> Task Harness Retrospective
        -> Review pending Harness Feedback
        -> Review Auto Memory proposals, when Auto Memory is enabled
-  -> Apply reviewed memory, when Auto Memory is enabled
+       -> Harness Engineer updates and commits memory, when Auto Memory is enabled
+  -> VCM records the committed memory result
 ```
 
 Memory proposal prompts sent to Project Manager, Architect, Coder, Tester, and
@@ -507,10 +510,10 @@ 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.
+the commit changes only assigned memory host files and only their
+`<VCM-memory>` blocks; it does not parse or apply Harness Engineer's semantic
+decisions. 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/adapters/git-adapter.js

@@ -157,6 +157,27 @@ export function createGitAdapter(runner) {
             }
             return result.stdout;
         },
+        async getChangedPaths(repoRoot, baseRef, headRef = null) {
+            const result = await runGit(runner, repoRoot, [
+                "diff",
+                "--name-only",
+                "-z",
+                baseRef,
+                ...(headRef ? [headRef] : [])
+            ]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_ERROR",
+                    message: "Unable to read changed Git paths.",
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+            return result.stdout
+                .split("\0")
+                .map((changedPath) => changedPath.trim())
+                .filter(Boolean);
+        },
         async getCommitList(repoRoot, range) {
             const result = await runGit(runner, repoRoot, ["log", "--format=%H%x00%s%x00%cI%x1e", range]);
             if (result.exitCode !== 0) {

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

@@ -7,7 +7,6 @@ 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 { 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" },
@@ -97,6 +96,26 @@ export function createAutoMemoryService(deps) {
         }
         return memory;
     }
+    async function writeRunMemoryHostSnapshot(taskRepoRoot, runId) {
+        for (const definition of MEMORY_FILE_DEFINITIONS) {
+            await deps.fs.writeText(resolveRepoPath(taskRepoRoot, memoryRunHostFilePath(runId, definition.path)), await deps.fs.readText(resolveRepoPath(taskRepoRoot, definition.path)));
+        }
+    }
+    async function assertOnlyMemoryBlocksChanged(taskRepoRoot, runId, currentMemory) {
+        for (const definition of MEMORY_FILE_DEFINITIONS) {
+            const beforeHost = await deps.fs.readText(resolveRepoPath(taskRepoRoot, memoryRunHostFilePath(runId, definition.path)));
+            const currentHost = await deps.fs.readText(resolveRepoPath(taskRepoRoot, definition.path));
+            const expectedHost = replaceVcmMemoryBlock(beforeHost, currentMemory[definition.path]);
+            if (currentHost !== expectedHost) {
+                throw new VcmError({
+                    code: "MEMORY_REVIEW_SCOPE_CHANGED",
+                    message: `Harness Engineer changed content outside the VCM memory block: ${definition.path}`,
+                    statusCode: 409,
+                    hint: "Restore non-memory content, keep only the reviewed <VCM-memory> edit, and commit the correction."
+                });
+            }
+        }
+    }
     async function getState(baseRepoRoot, taskRepoRoot) {
         let [active, runs, memoryFiles] = await Promise.all([
             loadActiveState(taskRepoRoot),
@@ -172,7 +191,6 @@ export function createAutoMemoryService(deps) {
         };
         const before = await readMemorySet(input.taskRepoRoot);
         await writeRunMemorySet(input.taskRepoRoot, runId, "before", before);
-        await writeRunMemorySet(input.taskRepoRoot, runId, "after", before);
         await snapshotArchitectPlanningCandidate(input.taskRepoRoot, runId);
         await persistRun(input.taskRepoRoot, {
             version: 1,
@@ -252,9 +270,31 @@ export function createAutoMemoryService(deps) {
             });
         }
         const proposalCandidates = await readReviewCandidates(taskRepoRoot, state);
+        const currentMemory = await readMemorySet(taskRepoRoot);
+        const beforeMemory = await readRunMemorySet(taskRepoRoot, state.runId, "before");
+        if (!sameHashes(hashMemorySet(currentMemory), hashMemorySet(beforeMemory))) {
+            throw new VcmError({
+                code: "MEMORY_TARGET_CHANGED",
+                message: "VCM memory changed while role proposals were being collected.",
+                statusCode: 409,
+                hint: "Review the current memory, then retry Auto Memory."
+            });
+        }
+        const memoryPaths = MEMORY_FILE_DEFINITIONS.map((definition) => definition.path);
+        const existingDiff = await deps.git.getDiff(taskRepoRoot, "HEAD", null, memoryPaths);
+        if (existingDiff.trim()) {
+            throw new VcmError({
+                code: "MEMORY_HOST_FILE_DIRTY",
+                message: "A file containing VCM memory has uncommitted changes before Harness Engineer review.",
+                statusCode: 409,
+                hint: "Commit or discard the existing host-file changes before starting Task Harness Retrospective."
+            });
+        }
+        await writeRunMemoryHostSnapshot(taskRepoRoot, state.runId);
         const timestamp = now();
         state.reviewPromptDispatchedAt = timestamp;
         state.retrospectiveReportPath = retrospectiveReportPath;
+        state.reviewBaseCommit = await deps.git.getHeadCommit(taskRepoRoot);
         state.updatedAt = timestamp;
         await persistActiveState(taskRepoRoot, state);
         const runRoot = resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}`);
@@ -263,7 +303,7 @@ export function createAutoMemoryService(deps) {
             runId: state.runId,
             roleDraftsPath: path.join(runRoot, "drafts"),
             currentMemoryPath: path.join(runRoot, "before"),
-            reviewedMemoryPath: path.join(runRoot, "after"),
+            activeMemoryPaths: memoryPaths.map((memoryPath) => resolveRepoPath(taskRepoRoot, memoryPath)),
             proposalCandidates,
             ...(planningCandidatePath
                 ? { planningCandidatePath: resolveRepoPath(taskRepoRoot, planningCandidatePath) }
@@ -277,6 +317,7 @@ export function createAutoMemoryService(deps) {
         }
         delete state.reviewPromptDispatchedAt;
         delete state.retrospectiveReportPath;
+        delete state.reviewBaseCommit;
         state.updatedAt = now();
         await persistActiveState(taskRepoRoot, state);
     }
@@ -362,26 +403,12 @@ export function createAutoMemoryService(deps) {
                 return true;
             }
             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;
-                }
+                await recordHarnessEngineerMemoryResult(input.taskRepoRoot, state);
             }
             catch (error) {
-                await failReview(input.taskRepoRoot, state, `Task Harness Retrospective memory review validation failed: ${errorMessage(error)}`);
+                await failReview(input.taskRepoRoot, state, `Harness Engineer memory result could not be recorded: ${errorMessage(error)}`);
                 return true;
             }
-            await applyReviewedMemory(input.taskRepoRoot, state);
             return true;
         }
         return true;
@@ -559,44 +586,75 @@ export function createAutoMemoryService(deps) {
         }
         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");
-            const after = await readRunMemorySet(taskRepoRoot, state.runId, "after");
-            assertCompleteMemorySet(after);
-            await applyAndCommitMemorySet(taskRepoRoot, before, after, "chore: update VCM memory");
-            const timestamp = now();
-            const diff = renderMemoryDiff(before, after);
-            const run = await readRun(taskRepoRoot, state.runId);
-            await persistRun(taskRepoRoot, {
-                ...run,
-                status: "applied",
-                updatedAt: timestamp,
-                appliedAt: timestamp,
-                afterHashes: hashMemorySet(after),
-                diff
+    async function recordHarnessEngineerMemoryResult(taskRepoRoot, state) {
+        if (!state.reviewBaseCommit) {
+            throw new VcmError({
+                code: "MEMORY_REVIEW_BASE_MISSING",
+                message: "Harness Engineer memory review has no recorded base commit.",
+                statusCode: 409,
+                hint: "Retry Auto Memory before running Task Harness Retrospective again."
             });
-            await deps.fs.writeText(resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}/applied.patch`), diff);
-            await clearActiveState(taskRepoRoot);
         }
-        catch (error) {
-            await failReview(taskRepoRoot, state, `Harness Engineer memory result could not be applied: ${errorMessage(error)}`);
+        const before = await readRunMemorySet(taskRepoRoot, state.runId, "before");
+        const after = await readMemorySet(taskRepoRoot);
+        await assertOnlyMemoryBlocksChanged(taskRepoRoot, state.runId, after);
+        const memoryPaths = MEMORY_FILE_DEFINITIONS.map((definition) => definition.path);
+        const uncommittedMemoryDiff = await deps.git.getDiff(taskRepoRoot, "HEAD", null, memoryPaths);
+        if (uncommittedMemoryDiff.trim()) {
+            throw new VcmError({
+                code: "MEMORY_REVIEW_NOT_COMMITTED",
+                message: "Harness Engineer left reviewed memory changes uncommitted.",
+                statusCode: 409,
+                hint: "Commit the reviewed <VCM-memory> changes before ending the retrospective turn."
+            });
+        }
+        const changedMemoryPaths = MEMORY_FILE_DEFINITIONS
+            .filter((definition) => before[definition.path] !== after[definition.path])
+            .map((definition) => definition.path);
+        const currentHead = await deps.git.getHeadCommit(taskRepoRoot);
+        const committedPaths = currentHead === state.reviewBaseCommit
+            ? []
+            : await deps.git.getChangedPaths(taskRepoRoot, state.reviewBaseCommit, currentHead);
+        const unexpectedPaths = committedPaths.filter((changedPath) => !memoryPaths.includes(changedPath));
+        if (unexpectedPaths.length > 0) {
+            throw new VcmError({
+                code: "MEMORY_REVIEW_COMMIT_SCOPE_INVALID",
+                message: `Harness Engineer memory commit contains files outside managed memory hosts: ${unexpectedPaths.join(", ")}`,
+                statusCode: 409,
+                hint: "Move unrelated changes to a separate workflow and keep the memory review commit limited to managed memory files."
+            });
+        }
+        const missingCommittedPaths = changedMemoryPaths.filter((changedPath) => !committedPaths.includes(changedPath));
+        if (missingCommittedPaths.length > 0) {
+            throw new VcmError({
+                code: "MEMORY_REVIEW_COMMIT_MISSING",
+                message: `Harness Engineer did not commit reviewed memory files: ${missingCommittedPaths.join(", ")}`,
+                statusCode: 409,
+                hint: "Commit every changed memory host file before ending the retrospective turn."
+            });
+        }
+        if (changedMemoryPaths.length === 0 && committedPaths.length > 0) {
+            throw new VcmError({
+                code: "MEMORY_REVIEW_EMPTY_COMMIT_RANGE",
+                message: "Harness Engineer created memory-host commits but left no final memory change.",
+                statusCode: 409,
+                hint: "Remove the unnecessary memory commits or leave memory unchanged without committing."
+            });
         }
+        await writeRunMemorySet(taskRepoRoot, state.runId, "after", after);
+        const timestamp = now();
+        const diff = renderMemoryDiff(before, after);
+        const run = await readRun(taskRepoRoot, state.runId);
+        await persistRun(taskRepoRoot, {
+            ...run,
+            status: "applied",
+            updatedAt: timestamp,
+            appliedAt: timestamp,
+            afterHashes: hashMemorySet(after),
+            diff
+        });
+        await deps.fs.writeText(resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}/applied.patch`), diff);
+        await clearActiveState(taskRepoRoot);
     }
     async function createAppliedRun(taskRepoRoot, taskSlug, source, before, after) {
         assertCompleteMemorySet(after);
@@ -815,27 +873,6 @@ function toReviewCandidates(source, currentRole, items) {
         ...(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,
@@ -902,6 +939,9 @@ function requireSafeRunId(runId) {
 function memoryRunFilePath(runId, snapshot, memoryPath) {
     return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/${snapshot}/${memoryPath}`;
 }
+function memoryRunHostFilePath(runId, memoryPath) {
+    return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/host-before/${memoryPath}`;
+}
 function missingMemoryBlockError(filePath) {
     return new VcmError({
         code: "MEMORY_BLOCK_MISSING",
@@ -923,12 +963,6 @@ function hashMemorySet(memory) {
         sha256(memory[definition.path] ?? "")
     ]));
 }
-function hasSubstantiveMemory(memory) {
-    return Object.values(memory).some((content) => {
-        const normalized = content.trim();
-        return Boolean(normalized && normalized !== "No accumulated project memory yet.");
-    });
-}
 function sameHashes(left, right) {
     return MEMORY_FILE_DEFINITIONS.every((definition) => left[definition.path] === right[definition.path]);
 }

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

@@ -401,6 +401,7 @@ export function createGateReviewService(deps) {
         const requestPath = path.posix.join(REQUESTS_DIR, `${requestId}.json`);
         const promptPath = path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
         const requestReportPath = reportPathForRequest(requestId);
+        const inputSnapshots = await captureGateInputSnapshots(deps.fs, context.taskRepoRoot, requestId, getSourceArtifacts(gate, codeDiffSources));
         const nextRecord = {
             ...record,
             status: "running",
@@ -444,13 +445,14 @@ export function createGateReviewService(deps) {
             codeDiffSource,
             codeDiffSources,
             codeDiff: codeDiffInput,
+            inputSnapshots,
             reportPath: requestReportPath,
             latestReportPath: nextRecord.reportPath,
             promptPath: nextRecord.promptPath
         });
         await saveIndex(deps.fs, context.taskRepoRoot, index);
         await notifyArchitecturePlanDisposition(context, gate, false);
-        void runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources).catch(() => {
+        void runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots).catch(() => {
             // runGateReview records failures in the persisted gate state.
         });
         return {
@@ -460,7 +462,7 @@ export function createGateReviewService(deps) {
             message: "Gate review started."
         };
     }
-    async function runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources) {
+    async function runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots = []) {
         const runKey = `${context.taskRepoRoot}:${context.taskSlug}:${gate}`;
         if (activeRuns.has(runKey)) {
             return;
@@ -476,7 +478,7 @@ export function createGateReviewService(deps) {
             await updateRequestStatus(deps.fs, context, requestId, "running", { startedAt: timestamp });
             const reviewDir = resolveRepoPath(context.taskRepoRoot, GATE_REVIEW_DIR);
             const agentPath = resolveRepoPath(context.repoRoot, REVIEWER_AGENT_PATH);
-            const prompt = buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources);
+            const prompt = buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots);
             await deps.fs.ensureDir(reviewDir);
             await deps.fs.ensureDir(resolveRepoPath(context.taskRepoRoot, REQUESTS_DIR));
             await deps.fs.writeText(resolveRepoPath(context.taskRepoRoot, promptPathForRequest(requestId)), prompt);
@@ -1130,12 +1132,22 @@ function splitLines(value) {
         .map((line) => line.trim())
         .filter(Boolean);
 }
-function buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources) {
+function buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots = []) {
     const reportPath = reportPathForRequest(requestId);
     const absoluteReportPath = resolveRepoPath(context.taskRepoRoot, reportPath);
     const evidence = getSourceArtifacts(gate, codeDiffSources)
         .map((relativePath) => `- ${relativePath}`)
         .join("\n");
+    const capturedEvidence = inputSnapshots.length > 0
+        ? `
+
+Captured Task Evidence:
+${inputSnapshots.map((snapshot) => snapshot.status === "captured"
+            ? `- ${snapshot.sourcePath} -> ${snapshot.snapshotPath}`
+            : `- ${snapshot.sourcePath} -> <missing at request time>`).join("\n")}
+
+Use each captured snapshot as the immutable handoff or prior-Gate input for this request. Do not substitute a later rewritten live artifact.`
+        : "";
     const gitLine = gate === "architecture-plan"
         ? "\nDiff: inspect git status/diff in Worktree."
         : "";
@@ -1174,7 +1186,7 @@ Request: ${requestId}
 Report: ${absoluteReportPath}
 
 Evidence:
-${evidence}${gitLine}${architectureContract}${validationContract}${codeDiffContract}${codeDiffSection}
+${evidence}${capturedEvidence}${gitLine}${architectureContract}${validationContract}${codeDiffContract}${codeDiffSection}
 
 Write only Report. Start exactly:
 Gate: ${gate}
@@ -1183,6 +1195,24 @@ Decision: approve|request_changes
 Summary: <one or two sentences>
 [/VCM GATE REVIEW]`;
 }
+async function captureGateInputSnapshots(fs, taskRepoRoot, requestId, sourcePaths) {
+    const snapshots = [];
+    for (const sourcePath of new Set(sourcePaths.filter(isTaskEvidencePath))) {
+        const absoluteSourcePath = resolveRepoPath(taskRepoRoot, sourcePath);
+        if (!(await fs.pathExists(absoluteSourcePath))) {
+            snapshots.push({ sourcePath, status: "missing" });
+            continue;
+        }
+        const snapshotPath = inputSnapshotPathForRequest(requestId, sourcePath);
+        await fs.writeText(resolveRepoPath(taskRepoRoot, snapshotPath), await fs.readText(absoluteSourcePath));
+        snapshots.push({ sourcePath, snapshotPath, status: "captured" });
+    }
+    return snapshots;
+}
+function isTaskEvidencePath(sourcePath) {
+    return sourcePath.startsWith(".ai/vcm/handoffs/")
+        || sourcePath.startsWith(".ai/vcm/gate-reviews/");
+}
 async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, intervalMs) {
     const reportPath = reportPathForRequest(requestId);
     while (true) {
@@ -1427,6 +1457,10 @@ function reportPathForRequest(requestId) {
 function promptPathForRequest(requestId) {
     return path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
 }
+function inputSnapshotPathForRequest(requestId, sourcePath) {
+    const taskEvidencePath = sourcePath.replace(/^\.ai\/vcm\//, "");
+    return path.posix.join(REQUESTS_DIR, `${requestId}.inputs`, taskEvidencePath);
+}
 function promptPathForGate(gate) {
     return path.posix.join(GATE_REVIEW_DIR, "prompts", `${gate}-gate.md`);
 }

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

@@ -250,13 +250,14 @@ export function createHarnessFeedbackService(deps) {
                     "Auto Memory Review:",
                     `Role drafts: ${memoryReview.roleDraftsPath}`,
                     `Current memory snapshot: ${memoryReview.currentMemoryPath}`,
+                    "Active memory files:",
+                    ...memoryReview.activeMemoryPaths.map((memoryPath) => `- ${memoryPath}`),
                     ...(memoryReview.planningCandidatePath
                         ? [`Architect planning-session candidate: ${memoryReview.planningCandidatePath}`]
                         : []),
-                    `Write the complete reviewed memory set to: ${memoryReview.reviewedMemoryPath}`,
                     "",
                     "Review every memory candidate against final task evidence while performing this retrospective.",
-                    "Each snapshot file contains only the matching <VCM-memory> block content. Edit every existing reviewed-memory file in place.",
+                    "The snapshot files contain only the matching pre-review <VCM-memory> block content.",
                     "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.",
@@ -265,12 +266,14 @@ export function createHarnessFeedbackService(deps) {
                     "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.",
+                    "Final content must be one exact line written to the selected active <VCM-memory> block. 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.",
                     "Use none as the complete Existing Memory Decisions body only when no substantive existing memory entry exists.",
+                    "Apply the reviewed result directly to the <VCM-memory> blocks in the listed active memory files. Do not change any content outside those blocks.",
+                    "If memory changes, commit only the changed active memory files before ending the turn. Use commit message: chore: update VCM memory. If memory is unchanged, do not create a commit.",
                     "Use this exact block in the retrospective report and replace each option or placeholder with one allowed value or a concise summary:",
                     "",
                     "## Memory Review",

package/dist/backend/templates/handoff.js

@@ -1,7 +1,10 @@
 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";
+const CURRENT_HANDOFF_NOTICE = "<!-- VCM current handoff: replace this file with one complete, self-contained snapshot of the current result. Restate all still-relevant evidence; do not refer to a prior revision, route message, Session, or transcript as evidence. -->";
 export function renderArchitectureBriefTemplate(taskSlug) {
     return `# Architecture Brief: ${taskSlug}
 
+${CURRENT_HANDOFF_NOTICE}
+
 Architecture Brief Status: ${renderArtifactOptions(ARCHITECTURE_BRIEF_STATUSES)}
 
 ## Accepted Outcome
@@ -28,6 +31,8 @@ TBD
 export function renderArchitecturePlanTemplate(taskSlug) {
     return `# Architecture Plan: ${taskSlug}
 
+${CURRENT_HANDOFF_NOTICE}
+
 Planning Result: ${renderArtifactOptions(ARCHITECTURE_PLAN_RESULTS)}
 
 ## Accepted Scope
@@ -135,6 +140,8 @@ TBD
 export function renderKnownIssuesTemplate(taskSlug) {
     return `# Known Issues: ${taskSlug}
 
+${CURRENT_HANDOFF_NOTICE}
+
 ## Task Issues
 
 No unresolved task issues recorded yet.
@@ -147,6 +154,8 @@ At task close, promote still-relevant confirmed issues to \`docs/known-issues.md
 export function renderTestReportTemplate(taskSlug) {
     return `# Test Report: ${taskSlug}
 
+${CURRENT_HANDOFF_NOTICE}
+
 Test Result: ${renderArtifactOptions(TEST_RESULTS)}
 
 ## Evidence Reviewed
@@ -249,6 +258,8 @@ ${STRICT_NONE_VALUE}
 export function renderCoderCompletionTemplate(taskSlug) {
     return `# Coder Completion: ${taskSlug}
 
+${CURRENT_HANDOFF_NOTICE}
+
 Decision: ready_for_review|incomplete|failed
 
 ## Scaffold Completion
@@ -293,6 +304,8 @@ TBD
 export function renderArchitectDebugTemplate(taskSlug) {
     return `# Architect Debug: ${taskSlug}
 
+${CURRENT_HANDOFF_NOTICE}
+
 Status: pending|completed
 
 ## PM-Routed Failure
@@ -342,6 +355,8 @@ TBD
 export function renderDocsSyncReportTemplate(taskSlug) {
     return `# Docs Sync Report: ${taskSlug}
 
+${CURRENT_HANDOFF_NOTICE}
+
 ## Summary
 
 TBD
@@ -378,6 +393,8 @@ ${renderArtifactOptions(DOCS_SYNC_DECISIONS)}
 export function renderFinalAcceptanceTemplate(taskSlug) {
     return `# Final Acceptance: ${taskSlug}
 
+${CURRENT_HANDOFF_NOTICE}
+
 ## Decision
 
 ${renderArtifactOptions(FINAL_ACCEPTANCE_DECISIONS)}

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

@@ -46,6 +46,9 @@ ${renderRoleMemoryRules("architect")}
 - Continue across module boundaries whenever the changed behavior path, state ownership, lifecycle, public contract, or failure path crosses them.
 - Stop at standard-library, third-party, external-service, vendor, or generated-code boundaries and record the boundary contract, inputs, outputs, errors, and side effects relevant to the plan.
 - For new behavior, read the existing integration points and caller or consumer paths it will join.
+- When a plan would add a file-local override, normalization, or bypass of a shared default, constant, or documented contract, search the current worktree for the same mechanism. If it already exists in at least two other files, treat the new occurrence as evidence of an upstream ownership or contract problem.
+- For every existing code site the plan or scaffold will change, inspect the complete callable unit or site and verify its current comments, contracts, preconditions, configuration scope, lifecycle assumptions, and safety assumptions against implementation and runtime configuration. Record the verified assumptions in \`architecture-evidence.md\`.
+- When the plan newly handles one member of an existing persisted structure, gate, invariant, or other semantic class, reconstruct the complete directly related member set and record its completeness basis in \`architecture-evidence.md\`.
 - Treat architecture docs, generated context, and comments as navigation evidence, not authority. Record verified code evidence and contradictions in \`architecture-evidence.md\`.
 - Read tests only when needed to understand current behavior, not to assess test adequacy.
 - Do not mark \`Architecture Evidence Status: complete\`, write Architecture Decision, or begin Code Scaffolding while a project-owned symbol remains unresolved on a behavior path the plan will change.
@@ -69,13 +72,16 @@ ${renderRoleMemoryRules("architect")}
 
 #### Plan Document
 
-- \`architecture-plan.md\` must start with \`Planning Result: complete|incomplete|user clarification required\` and use these sections: Accepted Scope, Current Code Reality, Architecture Decision, Module/File Plan, Public Surface Impact, Scaffold Manifest, Scaffold Build Evidence, Tester Coverage Hints, Docs Impact, Known Risks, and Coder Handoff Notes.
+- \`architecture-plan.md\` must start with \`Planning Result: complete|incomplete|user clarification required\` and use these sections: Accepted Scope, Current Code Reality, Existing Assumptions And Class Coverage, Architecture Decision, Module/File Plan, Public Surface Impact, Scaffold Manifest, Scaffold Build Evidence, Tester Coverage Hints, Docs Impact, Known Risks, and Coder Handoff Notes.
 - Use \`Planning Result: complete\` only when: the plan document is complete; the Scaffold Manifest ledger reconciles one to one against the committed markers; and \`Scaffold Build Evidence\` records a green compile/typecheck run at the current scaffold commit hash. Include the same Planning Result in the route message to project-manager; do not select the next route.
-- \`architecture-plan.md\` is the current executable plan, not a changelog. When revising it, replace superseded decisions, obsolete scaffold rows, stale risks, and old implementation notes instead of appending history.
+- \`architecture-plan.md\` is the complete, self-contained current executable plan, not a changelog. Each revision must restate every still-current decision, constraint, evidence reference, scaffold row, risk, and implementation instruction needed to execute and review the plan without a prior revision. Replace superseded decisions, obsolete scaffold rows, stale risks, and old implementation notes instead of appending history.
 - \`Accepted Scope\`: state the PM-routed task scope and the confirmed brief's required user-visible outcome and decisions, plus any explicit non-scope that prevents accidental expansion.
 - \`Current Code Reality\`: cite \`architecture-evidence.md\` and summarize only the verified facts that constrain the architecture decision. Do not duplicate the full evidence inventory. For any module whose build configuration the plan changes, the evidence artifact must quote its complete direct dependency list from the package manifest, never a summary or selection.
 - Any enumeration the plan presents as complete over the codebase — call-site inventories, module or file lists, symbol sets — must either record the deterministic, repository-local command that generates it (run at the scaffold commit, the set transcribed from its output) or be explicitly marked as judgment-derived with the evidence basis for its completeness. A complete-claimed enumeration with neither is not evidence.
+- \`Existing Assumptions And Class Coverage\`: include a \`Touched Site | Verified Assumption Or Contract | Evidence | Plan Effect | Disposition\` table and a \`Class Source | Completeness Basis | Member | Plan Disposition\` table. Cover every existing code site named by the Module/File Plan or Scaffold Manifest, including assumptions the plan preserves, updates, or invalidates. When the plan newly handles one member of an existing persisted structure, gate, invariant, or other semantic class, list every directly related member and its disposition. A bare \`None.\` is allowed only when the plan changes no existing code site and handles no member of an existing class.
 - \`Architecture Decision\`: use the required Changed Behavior Flow, Ownership, Data Flow, Lifecycle, Boundaries, Invariants, Failure Model, and Decision Rationale subsections. Describe why the design fits verified current code.
+- Correct every verified existing assumption that the plan invalidates through the Architecture Decision, affected callable surfaces, scaffold, and docs impact. Do not leave Coder to discover or reconcile the contradiction.
+- When the repeated-workaround threshold is met, \`Architecture Decision\` must explicitly fix the owning behavior, confirm that local handling is intended and correct the owning documentation, or record the unresolved issue and affected call sites through Known Issues Sync. Extracting the workaround into a helper is not an upstream disposition.
 - \`Module/File Plan\`: list each affected module, changed or created file, file responsibility, why it is in scope, expected change, dependency direction, user-visible behavior change, durable comment needs, and every non-private callable surface intended for use outside its file. For every ledger item that consumes or sources cross-module data, name the module and symbol that owns or produces the data, trace the source-to-consumer path, and identify every field, parameter, accessor, trait method, command field, dependency, or other cross-file surface required by that path.
 - \`Public Surface Impact\`: state changed APIs, routes, commands, events, exports, storage formats, configuration, UI behavior, visibility changes, side effects, error boundaries, expected callers, or explicitly state none.
 - \`Scaffold Manifest\`: an item ledger — one entry per implementation item. Use columns in the exact order \`ID | Action | File | ...\`; use an ID matching \`AA-1\` through \`AAAAAA-9999\`, an Action of exactly \`create\`, \`change\`, or \`delete\`, and a backticked repo-relative File path. An item is one created body or surface, one required change site — one contiguous edit region inside an existing body or surface — or one deletion of a body, site, or file. An item not in the ledger is not in the plan; coder must not implement it.
@@ -143,7 +149,7 @@ ${renderRoleMemoryRules("architect")}
 - Before handing off an architect-completed Debug Mode fix, run the smallest relevant L0 fast checks for the touched files or changed modules: format, lint, typecheck, boundary, dependency, or project-defined equivalents. If a check cannot run, report the exact reason.
 - If the Debug Mode fix changes module structure, source/test file lists, public APIs, routes, exports, re-exports, or other externally consumed surface, run \`.ai/tools/generate-module-index\` / \`.ai/tools/generate-public-surface\` or their \`--check\` mode as applicable.
 - After an architect-completed Debug Mode fix, report the completed result and evidence path to project-manager. Do not select the next route.
-- Before reporting a completed Debug Mode code fix, replace \`.ai/vcm/handoffs/architect-debug.md\` with current evidence. Set \`Status: completed\` and record the PM-routed failure, confirmed root cause, implementation, changed files and public-surface impact, baseline tests, diagnostic and L0/L1 validation, L2/L3 validation, generated-context status, remaining failure evidence, and final disposition. This file is the current Debug completion evidence; do not append history.
+- Before reporting a completed Debug Mode code fix, replace \`.ai/vcm/handoffs/architect-debug.md\` with complete, self-contained current evidence. Set \`Status: completed\` and restate the PM-routed failure, confirmed root cause, implementation, changed files and public-surface impact, baseline tests, diagnostic and L0/L1 validation, L2/L3 validation, generated-context status, remaining failure evidence, and final disposition needed to review the result without a prior revision. Remove superseded evidence instead of appending history.
 - Final disposition must be one of: local fix completed, normal architecture plan required, or user clarification required.
 - Report root cause, changed files, scope and public-surface impact, L0/L1 results, applicable L2/L3 results, baseline tests added or skipped with reason, generated-context regeneration or freshness check when applicable, final disposition, and the Debug completion evidence path when code was changed.
 
@@ -213,6 +219,8 @@ Small diff, minimum change, localized fix, or preserving the current implementat
 9. \`Implementation And Validation\`
 10. \`Final Disposition\`
 
+Each rewritten \`architecture-diagnosis.md\` must be a complete, self-contained current diagnosis and implementation result. Restate all still-relevant code-reading closure, evidence, architecture findings, changes, validation, and remaining failure evidence; do not refer to a prior round or superseded diagnosis as evidence.
+
 \`Implementation And Validation\` must use these subsections: \`Changed Files And Public Surface\`, \`Baseline Tests\`, \`Diagnostic And L0/L1 Validation\`, \`L2/L3 Validation\`, \`Generated Context\`, and \`Commit\`.
 
 \`L2/L3 Validation\` must use this table:
@@ -301,6 +309,7 @@ Small diff, minimum change, localized fix, or preserving the current implementat
 - Write \`.ai/vcm/handoffs/docs-sync-report.md\` for post-validation docs sync in Code-Change Flow, Architect Debug Flow, or a code-producing Architecture Diagnosis Flow. Do not write it for Docs-Only Flow or a Debug/Diagnosis Branch.
 - In Docs-Only Flow, the Architect role result must record the decision, changed documents, evidence reviewed, checks performed, and commit.
 - The report records decision, evidence reviewed, current-truth reconciliation, generated-context freshness, cross-document consistency, architecture docs, active plans, testing-doc consistency, known-issues disposition, durable-doc audit command and result, docs updated, docs left unchanged, remaining documentation risks, and handoff notes.
+- Each rewritten \`docs-sync-report.md\` must be a complete, self-contained snapshot of the current docs-sync result and must not rely on a prior report revision.
 - \`Decision\` must be \`synced\`, \`unchanged\`, or \`blocked\`.
 
 ### Background Jobs

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

@@ -66,6 +66,14 @@ If a reusable harness problem is suspected, it is enough to record a concise fee
 - Runtime task records and handoffs under \`.ai/vcm/\` are temporary. Durable facts must move into code, tests, PR text, commit history, or long-term docs.
 - Only architect writes \`.ai/vcm/handoffs/known-issues.md\`; other roles report unresolved findings back through their own handoff artifacts.
 
+## VCM Current Handoff Contract
+
+- A role-owned handoff under \`.ai/vcm/handoffs/\` is the complete current result for that artifact, not an append-only log or a pointer to an earlier revision.
+- Whenever a handoff is rewritten, make the new revision self-contained: restate every still-relevant decision, evidence item, command, result, coverage mapping, finding, approval, and remaining action needed to interpret the current result without another round's artifact.
+- Remove or replace superseded content. Do not use a prior round, prior report revision, consumed route message, role Session, or transcript as a substitute for evidence in the current handoff.
+- A handoff may cite current code, durable docs, commits, preserved job output, or request-scoped Gate Review evidence that still exists at the cited path.
+- Before routing an artifact reference, confirm the referenced handoff satisfies this contract.
+
 ## User Communication
 
 - A message without a VCM marker is user communication.

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

@@ -70,7 +70,7 @@ ${renderRoleMemoryRules("coder")}
 
 ### Handoff
 
-- Write \`.ai/vcm/handoffs/coder-completion.md\` before routing back to project-manager. This file is the current implementation completion evidence, not a log; replace stale content instead of appending history.
+- Write \`.ai/vcm/handoffs/coder-completion.md\` before routing back to project-manager. This file is the complete, self-contained current implementation completion evidence, not a log. Each revision must restate every Scaffold Manifest disposition, changed file, helper, deviation, generated-context result, baseline-test change, L0/L1 command and result, worker result, commit, and objective failure still needed to review the current implementation without a prior revision. Replace stale content instead of appending history.
 - \`coder-completion.md\` must include \`Decision: ready_for_review | incomplete | failed\`.
 - \`coder-completion.md\` must report every Scaffold Manifest item disposition in the fixed Scaffold Completion table, plus changed files, private helpers added, manifest deviations as report-only facts, generated context status, baseline tests added or updated, L0/L1 commands and results, worker commits and integration status when workers were used, and compile/typecheck or L0/L1 failures.
 - Use this structure:

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

@@ -8,6 +8,8 @@ ${renderRoleMemoryRules("reviewer")}
 
 Review only the gate in the VCM prompt. Use the task and worktree paths named there. Project memory may orient you, but only current worktree evidence can decide the gate.
 
+When the VCM prompt maps a task-evidence path to an immutable request snapshot, review that snapshot as the handoff or prior-Gate input for this request. Do not substitute a later rewritten live handoff. Continue to inspect current code, tests, durable docs, generated context, and the named commit range wherever the gate requires current-worktree evidence.
+
 Use only these decisions:
 
 - \`approve\`: required gate evidence is present, current, internally consistent, sufficient for that gate, and has no gate-blocking finding.
@@ -117,6 +119,26 @@ of verifying only the cited instances. A claimed-complete enumeration with
 neither a recorded command nor a judgment-derived basis, or one that fails
 reconstruction, is unsupported by code evidence and is \`request_changes\`.
 
+Run a backward-impact pass over the plan:
+
+- For every existing code site named by the Module/File Plan or Scaffold
+  Manifest, inspect the complete callable unit or site and verify its current
+  comments, contracts, preconditions, configuration scope, lifecycle
+  assumptions, and safety assumptions against implementation and runtime
+  configuration.
+- Identify which verified assumptions the plan preserves, updates, or
+  invalidates. Request changes when the plan omits a touched site, misstates an
+  assumption, or invalidates one without correcting the architecture, affected
+  surfaces, scaffold, and docs impact.
+- When the plan newly handles one member of an existing persisted structure,
+  gate, invariant, or other semantic class, independently reconstruct the
+  complete directly related member set from its declaration, catalogue,
+  adjacent contract, or repository search. Verify that every member has an
+  evidence-backed plan disposition.
+- Keep this pass bounded to plan-cited or scaffold-touched existing sites and
+  their directly related semantic classes. Do not expand it into an unrelated
+  whole-repository review.
+
 Request changes when the plan is structurally complete but architecturally
 under-specified, logically inconsistent, unsupported by code evidence, unsafe
 for boundary cases, conflicts with current project architecture, or leaves key
@@ -272,6 +294,18 @@ Verify that the Diagnosis evidence records applicable L2/L3 validation for the
 diagnosed failure path. Request changes when an applicable check was not run,
 did not pass, or does not exercise that failure path.
 
+When a changed production or test hunk adds a file-local override,
+normalization, or bypass of a shared default, constant, or documented contract,
+search the current worktree for the same mechanism. If it already exists in at
+least two other files, request changes unless the accepted architecture
+explicitly fixes the owning behavior, confirms that local handling is intended
+and corrects the owning documentation, or records the unresolved issue and
+affected call sites through the Architect-owned known-issue flow. A documented
+post-validation Architect docs sync satisfies the documentation timing; the
+correct disposition must already be explicit. Extracting the workaround into a
+helper is not an upstream disposition. Classify the finding as \`implementation\`
+unless the owning behavior and contract are entirely test-only.
+
 Check every source for project coding-standard compliance, unnecessary
 duplication or abstraction, inconsistent error handling, unhandled fallible
 paths, debug/task-only artifacts, \`VCM:CODE\`, task-process comments or labels,
@@ -313,6 +347,8 @@ Use this findings structure:
 - End-To-End Flow:
 - Scope Fit:
 - Code Reality:
+- Invalidated Assumptions:
+- Existing-Class Completeness:
 - Ownership:
 - Data Flow:
 - Lifecycle:

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

@@ -39,21 +39,22 @@ You are not part of the task workflow round state.
   yourself.
 - Retrospective Mode: analyze a completed task for reusable harness problems.
   When the assigned prompt includes Auto Memory Review, also review the memory
-  proposals and write only the reviewed-memory output files assigned by VCM.
+  proposals, update the active \`<VCM-memory>\` blocks, and commit those memory
+  changes yourself.
 - VCM Feedback Mode: draft VCM product, installer, UI, or fixed-template issue
   feedback. Do not submit without explicit in-session user authorization.
 
 ## Change Policy
 
-- Apply edits only in Bootstrap Apply Mode, to assigned reviewed-memory output
-  files during Retrospective Mode, or when VCM explicitly asks you to apply an
-  approved harness change.
+- Apply edits only in Bootstrap Apply Mode, to active \`<VCM-memory>\` blocks
+  during an assigned Auto Memory Retrospective, or when VCM explicitly asks you
+  to apply an approved harness change.
 - When applying edits, work only in the active task worktree named by VCM. Do not
   edit the base repository root unless VCM explicitly says so.
 - In Proposal Mode, do not edit files.
 - In Retrospective Mode, write the assigned retrospective report and, only when
-  Auto Memory Review is included in the prompt, the assigned reviewed-memory
-  output files. After every assigned pending feedback has a recorded
+  Auto Memory Review is included in the prompt, directly update the assigned
+  active memory blocks. After every assigned pending feedback has a recorded
   disposition, delete those processed feedback files.
 - Commit every applied harness change yourself before ending your turn.
 - Do not overwrite VCM fixed managed blocks.
@@ -92,9 +93,13 @@ You are not part of the task workflow round state.
   assigned by VCM.
 - Do not record task narrative, temporary state, unverified conclusions, or
   Harness rules in memory.
-- Edit only the review output paths assigned by VCM. Do not edit active
-  \`<VCM-memory>\` blocks directly. VCM applies the reviewed output, records the
-  diff, and commits the changed host files.
+- Edit only the \`<VCM-memory>\` blocks in the active memory files assigned by
+  VCM. Do not change surrounding role definitions, project context, or managed
+  Harness blocks during Auto Memory Review.
+- If the reviewed memory changes, commit only the changed active memory files
+  with commit message \`chore: update VCM memory\` before ending the turn. If
+  memory is unchanged, do not create a commit. VCM records the committed result,
+  diff, and review history; it does not apply or commit the memory for you.
 
 ## Task Harness Retrospective
 

package/dist/backend/templates/harness/project-coding-standards.js

@@ -18,6 +18,8 @@ Project-specific rules may be added outside the VCM managed block when they make
 - Do not derive logic from visible test fixtures, fixed sample values, snapshot text, or special branches that only satisfy known tests.
 - Coder and Coder Worker keep the diff inside the approved plan. In Debug Mode or Architecture Diagnosis Mode, Architect owns the technical change boundary after confirming the root cause.
 - Preserve existing behavior unless the approved plan or a confirmed Debug/Diagnosis root cause changes it.
+- Do not introduce the same file-local override, normalization, or bypass of a shared default, constant, or documented contract into a third file unless the accepted architecture explicitly fixes the owning behavior, confirms local handling is intended and corrects the owning documentation, or records the unresolved issue and affected call sites through the Architect-owned known-issue flow.
+- Extracting the repeated local workaround into a helper is not an upstream disposition.
 
 ## Comments
 

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

@@ -179,7 +179,7 @@ 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 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.
+- \`test-report.md\` is the complete, self-contained current validation evidence, not a log. Each revision must independently support its current \`Test Result\` by restating every still-relevant test or external check, coverage mapping, command and result, test-infrastructure fact, failed expectation, skipped check, gap, approval, blocking issue, and remaining validation needed to review that result without a prior revision. Remove superseded evidence, but never replace current evidence with “as recorded in the prior round”, a prior report reference, or a Session/transcript reference.
 - 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.

package/dist/backend/templates/harness/vcm-architecture-interview-skill.js

@@ -18,6 +18,8 @@ During an active Architect Interview, handle the user's answers and final confir
 - If a fact can be established from the worktree or available tools, investigate it instead of asking the user.
 - If code, docs, and the user's requested behavior conflict, state the concrete conflict and ask which user-visible behavior is intended.
 - Maintain \`.ai/vcm/handoffs/architecture-evidence.md\` while reading. Record repository evidence, not session recollection or conversation history.
+- For every existing code site the drafted mechanism may change, record the site's verified safety, configuration, lifecycle, state, data, and contract assumptions. Treat comments and docs as claims to verify against implementation and runtime configuration, not as authority or text to ignore.
+- When the draft newly handles one member of an existing persisted structure, gate, invariant, or other semantic class, reconstruct and record the complete directly related member set and the evidence basis for its completeness.
 
 ## Feasibility Draft
 
@@ -89,6 +91,10 @@ Architecture Evidence Status: incomplete|complete
 
 ## Callers And Consumers
 
+## Existing Assumptions
+
+## Related Class Inventories
+
 ## External Boundaries
 
 ## Code And Docs Conflicts
@@ -96,7 +102,7 @@ Architecture Evidence Status: incomplete|complete
 ## Evidence Commands
 \`\`\`
 
-Identify inspected files and symbols, callers or consumers, state and side effects, verified behavior, and the worktree revision. Replace stale evidence instead of appending history.
+Identify inspected files and symbols, callers or consumers, state and side effects, verified behavior, existing assumptions and their scope, related class members and their completeness basis, and the worktree revision. Replace stale evidence instead of appending history.
 
 ## Completion
 

package/dist/backend/templates/harness/vcm-final-acceptance-skill.js

@@ -123,6 +123,8 @@ accepted|accepted-with-known-risks|needs-coder-follow-up|needs-architect-follow-
 ## Final User Summary
 \`\`\`
 
+Each rewrite must be a complete, self-contained snapshot of the current acceptance decision and supporting evidence. Restate every still-relevant evidence result, file classification, validation result, Gate decision, docs-sync result, known-issues disposition, cleanup result, risk, and next action; do not rely on a prior acceptance revision, route message, Session, or transcript.
+
 The final user summary should be concise and include files changed, validation, docs updates, open risks, and next action.
 `;
 }

package/dist/backend/templates/harness/vcm-route-message-skill.js

@@ -44,7 +44,7 @@ If the same route file already contains a not-yet-delivered message, update that
 
 ## Message Format
 
-Use the smallest body that is complete. Include artifact refs instead of copying long documents.
+Use the smallest body that is complete. Include artifact refs instead of copying long documents. Reference a role handoff only after confirming its current revision is complete and self-contained; never use an artifact ref to stand in for evidence that exists only in a prior revision, consumed route message, Session, or transcript.
 
 For simple user relay, use a lightweight body instead of the formal dispatch format.
 

package/package.json

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

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

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