vibe-coding-master 0.7.31 → 0.7.33

package/README.md

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

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

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

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

@@ -260,9 +260,13 @@ export function createHarnessFeedbackService(deps) {
                     "Before evaluating proposals, review every substantive entry in every current memory snapshot against current code, documentation, and final task evidence.",
                     "For each existing entry, decide retain, update, remove, or move-to-durable-doc. Record the decision reason, the impact of removing it, and whether memory or a durable document is the correct source.",
                     "Complete this full existing-memory review even when every proposal says no-change.",
-                    "Then evaluate every proposal, including its stated need, absence impact, and durable-document disposition.",
+                    "Then evaluate every proposal item independently. Do not accept or reject a whole role draft as one decision.",
+                    "For every Add or Update candidate, independently explain why the memory is necessary, what fails if it is absent, and why memory or a durable document is the correct destination.",
+                    "Do not copy the proposer rationale as the review. Verify it against current code, durable documentation, and final task evidence.",
                     "Keep only verified, durable, reusable project knowledge. Merge duplicates and keep role-specific knowledge in the matching role file.",
                     "Do not record task narrative, temporary state, unverified conclusions, or Harness rules in memory.",
+                    "Final content must be one exact line written to the selected reviewed-memory file. Use none when the decision does not keep memory.",
+                    "For keep-in-memory use Durable doc disposition: memory. For keep-memory-reference use memory-reference. For move-to-durable-doc use durable-doc.",
                     "Existing-memory Target must be shared or the exact role name. Decision must be retain, update, remove, or move-to-durable-doc.",
                     "Durable doc disposition must be memory, durable-doc, or memory-reference. Use Durable doc path: none with memory and an actual path with the other dispositions.",
                     "Do not keep full content in memory when durable-doc is correct. Use memory-reference only when an ongoing role needs the document pointer.",
@@ -272,8 +276,10 @@ export function createHarnessFeedbackService(deps) {
                     "## Memory Review",
                     "Existing memory reviewed: complete",
                     "",
-                    "### Proposal Dispositions",
-                    ...memoryReview.proposalRoles.map((role) => `- ${role}: accepted|rejected|no-change`),
+                    "### Proposal Decisions",
+                    ...(memoryReview.proposalCandidates.length > 0
+                        ? memoryReview.proposalCandidates.flatMap(renderMemoryProposalDecisionTemplate)
+                        : ["none"]),
                     "",
                     "### Existing Memory Decisions",
                     "#### Item 1",
@@ -299,6 +305,38 @@ export function createHarnessFeedbackService(deps) {
             "End your turn after writing the result."
         ].join("\n");
     }
+    function renderMemoryProposalDecisionTemplate(candidate) {
+        if (candidate.operation === "remove") {
+            return [
+                `#### Candidate ${candidate.id}`,
+                `Source: ${candidate.source}`,
+                "Operation: remove",
+                `Target: ${candidate.target}`,
+                `Existing: ${candidate.existing}`,
+                "Decision: remove|retain",
+                "Reason: <why the proposed removal should be applied or rejected>",
+                "Evidence checked: <current code, durable documentation, or final task evidence>",
+                ""
+            ];
+        }
+        return [
+            `#### Candidate ${candidate.id}`,
+            `Source: ${candidate.source}`,
+            `Operation: ${candidate.operation}`,
+            `Target: ${candidate.target}`,
+            `Candidate: ${candidate.content}`,
+            "Decision: keep-in-memory|keep-memory-reference|move-to-durable-doc|reject",
+            "Final target: shared|project-manager|architect|coder|tester|reviewer|harness-engineer|none",
+            "Why memory is necessary: <independent reason, or why it is not necessary>",
+            "Impact if absent: <specific impact, or why no durable impact exists>",
+            "Durable doc disposition: memory|durable-doc|memory-reference",
+            "Durable doc analysis: <why this destination is correct>",
+            "Durable doc path: <none or a project-relative durable doc path>",
+            "Evidence checked: <current code, durable documentation, or final task evidence>",
+            "Final content: <exact one-line reviewed-memory content or none>",
+            ""
+        ];
+    }
     function buildPendingFeedbackPrompt(repoRoot, feedbackPath) {
         return [
             "[VCM Harness Feedback]",

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

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

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

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

package/dist/backend/templates/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.
 - \`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.

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

@@ -117,6 +117,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 +292,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 +345,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

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

package/dist/backend/templates/harness/project-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/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/package.json

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