vibe-coding-master 0.7.31 → 0.7.32

package/README.md

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

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

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

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

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