vibe-coding-master 0.7.43 → 0.7.45

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

@@ -10,6 +10,7 @@ const REVIEWER_AGENT_PATH = ".claude/agents/reviewer.md";
 const GATE_REVIEW_DIR = ".ai/vcm/gate-reviews";
 const REQUESTS_DIR = ".ai/vcm/gate-reviews/requests";
 const GATE_REVIEW_VERSION = 1;
+const HARNESS_COMMIT_PREFIX = "[VCM Harness] ";
 const REVIEWER_ROLE = "reviewer";
 const DEFAULT_REPORT_POLL_INTERVAL_MS = 1000;
 const activeRuns = new Map();
@@ -107,6 +108,7 @@ export function createGateReviewService(deps) {
             taskSlug,
             taskRepoRoot,
             stateRoot: projectConfig.stateRoot,
+            handoffDir: task.handoffDir,
             config: loadRuntimeConfig(reviewSettings)
         };
     }
@@ -345,42 +347,21 @@ export function createGateReviewService(deps) {
             }
         }
         if (gate === "code-diff") {
-            const prerequisiteError = await readCodeDiffPrerequisiteError(deps, context, index, codeDiffSource);
-            if (prerequisiteError) {
-                index = applyGateState(index, gate, {
-                    status: "failed",
-                    decision: undefined,
-                    error: prerequisiteError,
-                    exceptionReason: undefined,
-                    requestId: undefined,
-                    requestPath: undefined,
-                    inputHash: undefined,
-                    baseCommit: undefined,
-                    headCommit: undefined,
-                    commits: undefined,
-                    changedFiles: undefined,
-                    diffStat: undefined,
-                    codeDiffSource,
-                    codeDiffSources: codeDiffSource ? [codeDiffSource] : undefined,
-                    requestedAt: undefined,
-                    startedAt: undefined,
-                    completedAt: now(),
-                    callbackStatus: "not_sent",
-                    callbackError: undefined
-                }, now(), true);
-                await saveIndex(deps.fs, context.taskRepoRoot, index);
+            const evidenceError = await readCodeDiffEvidenceError(deps.fs, context.taskRepoRoot, codeDiffSource);
+            if (evidenceError) {
+                index = await recordCodeDiffStartFailure(index, context, gate, codeDiffSource, evidenceError);
                 return {
                     status: "failed_to_start",
                     gate,
                     record: index.gates[gate],
-                    message: prerequisiteError
+                    message: evidenceError
                 };
             }
         }
         const codeDiffInput = gate === "code-diff"
             ? await resolveCodeDiffInput(deps, context, record)
             : undefined;
-        if (gate === "code-diff" && !codeDiffInput) {
+        if (gate === "code-diff" && (!codeDiffInput || codeDiffInput.commits.length === 0)) {
             index = applyGateState(index, gate, {
                 status: "not_required",
                 decision: undefined,
@@ -389,16 +370,16 @@ export function createGateReviewService(deps) {
                 requestId: undefined,
                 requestPath: undefined,
                 inputHash: undefined,
-                baseCommit: undefined,
-                headCommit: undefined,
-                commits: undefined,
-                changedFiles: undefined,
-                diffStat: undefined,
+                baseCommit: codeDiffInput?.baseCommit,
+                headCommit: codeDiffInput?.headCommit,
+                commits: codeDiffInput?.commits,
+                changedFiles: codeDiffInput?.changedFiles,
+                diffStat: codeDiffInput?.diffStat,
                 codeDiffSource,
                 codeDiffSources: codeDiffSource ? [codeDiffSource] : undefined,
                 requestedAt: undefined,
                 startedAt: undefined,
-                completedAt: undefined,
+                completedAt: codeDiffInput ? now() : undefined,
                 callbackStatus: "not_sent",
                 callbackError: undefined
             }, now(), true);
@@ -407,11 +388,51 @@ export function createGateReviewService(deps) {
                 status: "not_required",
                 gate,
                 record: index.gates[gate],
-                message: "No new commits to review."
+                message: codeDiffInput ? "No non-Harness commits to review." : "No new commits to review."
             };
         }
-        const codeDiffSources = gate === "code-diff" && codeDiffInput && codeDiffSource
-            ? resolveCodeDiffSources(record, codeDiffInput, codeDiffSource)
+        if (gate === "code-diff") {
+            const prerequisiteError = await readCodeDiffValidationGateError(deps, context, index);
+            if (prerequisiteError) {
+                index = await recordCodeDiffStartFailure(index, context, gate, codeDiffSource, prerequisiteError, codeDiffInput);
+                return {
+                    status: "failed_to_start",
+                    gate,
+                    record: index.gates[gate],
+                    message: prerequisiteError
+                };
+            }
+        }
+        async function recordCodeDiffStartFailure(currentIndex, currentContext, currentGate, currentSource, message, currentCodeDiffInput) {
+            const failedIndex = applyGateState(currentIndex, currentGate, {
+                status: "failed",
+                decision: undefined,
+                error: message,
+                exceptionReason: undefined,
+                requestId: undefined,
+                requestPath: undefined,
+                inputHash: undefined,
+                baseCommit: currentCodeDiffInput?.baseCommit,
+                headCommit: currentCodeDiffInput?.headCommit,
+                commits: currentCodeDiffInput?.commits,
+                changedFiles: currentCodeDiffInput?.changedFiles,
+                diffStat: currentCodeDiffInput?.diffStat,
+                codeDiffSource: currentSource,
+                codeDiffSources: currentSource ? [currentSource] : undefined,
+                requestedAt: undefined,
+                startedAt: undefined,
+                completedAt: now(),
+                callbackStatus: "not_sent",
+                callbackError: undefined
+            }, now(), true);
+            await saveIndex(deps.fs, currentContext.taskRepoRoot, failedIndex);
+            return failedIndex;
+        }
+        const currentCodeDiffSources = gate === "code-diff" && codeDiffSource
+            ? await resolveWorkflowCodeDiffSources(deps, context, codeDiffSource)
+            : undefined;
+        const codeDiffSources = gate === "code-diff" && codeDiffInput && currentCodeDiffSources
+            ? resolveCodeDiffSources(record, codeDiffInput, currentCodeDiffSources)
             : undefined;
         const inputHash = await computeInputHash(deps, context.taskRepoRoot, gate, codeDiffInput, codeDiffSources);
         if (!options.force
@@ -1059,44 +1080,78 @@ async function resolveCodeDiffInput(deps, context, record) {
         return undefined;
     }
     const range = `${baseCommit}..${headCommit}`;
-    const commits = splitLines(await commandStdout(deps.runner, context.taskRepoRoot, [
+    const allCommits = splitLines(await commandStdout(deps.runner, context.taskRepoRoot, [
         "log",
         "--oneline",
         "--reverse",
         range
     ]));
-    if (commits.length === 0) {
+    if (allCommits.length === 0) {
         return undefined;
     }
-    const changedFiles = splitLines(await commandStdout(deps.runner, context.taskRepoRoot, [
-        "diff",
-        "--name-only",
-        "--find-renames",
-        range
-    ]));
-    const diffStat = await commandStdout(deps.runner, context.taskRepoRoot, [
-        "diff",
-        "--stat",
-        "--find-renames",
-        range
-    ]);
-    const diff = await commandStdout(deps.runner, context.taskRepoRoot, [
-        "diff",
-        "--binary",
-        "--find-renames",
-        range
-    ]);
+    const commits = allCommits.filter((line) => !isHarnessCommitLine(line));
+    const commitShas = commits.map(commitShaFromOneline);
+    const changedFiles = new Set();
+    const diffStats = [];
+    const diffs = [];
+    for (const commitSha of commitShas) {
+        for (const changedFile of splitLines(await commandStdout(deps.runner, context.taskRepoRoot, [
+            "show",
+            "--format=",
+            "--name-only",
+            "--find-renames",
+            commitSha
+        ]))) {
+            changedFiles.add(changedFile);
+        }
+        const stat = await commandStdout(deps.runner, context.taskRepoRoot, [
+            "show",
+            "--format=",
+            "--stat",
+            "--find-renames",
+            commitSha
+        ]);
+        if (stat.trim()) {
+            diffStats.push(stat.trim());
+        }
+        const patch = await commandStdout(deps.runner, context.taskRepoRoot, [
+            "show",
+            "--format=",
+            "--binary",
+            "--find-renames",
+            commitSha
+        ]);
+        if (patch) {
+            diffs.push(patch);
+        }
+    }
+    const diffStat = diffStats.join("\n");
+    const diff = diffs.join("\n");
     const diffHash = createHash("sha256").update(diff).digest("hex");
     return {
         baseCommit,
         headCommit,
         commits,
-        changedFiles,
+        commitShas,
+        changedFiles: [...changedFiles],
         diffStat,
         diffHash
     };
 }
+function commitShaFromOneline(line) {
+    return line.split(/\s+/, 1)[0] ?? line;
+}
+function isHarnessCommitLine(line) {
+    const separator = line.indexOf(" ");
+    return separator >= 0 && line.slice(separator + 1).startsWith(HARNESS_COMMIT_PREFIX);
+}
 async function resolveCodeDiffBaseCommit(deps, context, record, headCommit) {
+    if (record.gate === "code-diff"
+        && record.status === "failed"
+        && record.baseCommit
+        && await isAncestor(deps.runner, context.taskRepoRoot, record.baseCommit, headCommit)) {
+        return record.baseCommit;
+    }
     if (record.gate === "code-diff"
         && record.status === "completed"
         && record.decision === "request_changes"
@@ -1111,6 +1166,12 @@ async function resolveCodeDiffBaseCommit(deps, context, record, headCommit) {
         && await isAncestor(deps.runner, context.taskRepoRoot, record.headCommit, headCommit)) {
         return record.headCommit;
     }
+    if (record.gate === "code-diff"
+        && record.status === "not_required"
+        && record.headCommit
+        && await isAncestor(deps.runner, context.taskRepoRoot, record.headCommit, headCommit)) {
+        return record.headCommit;
+    }
     const rootHead = (await commandStdout(deps.runner, context.repoRoot, ["rev-parse", "HEAD"])).trim();
     if (rootHead
         && rootHead !== headCommit
@@ -1165,7 +1226,7 @@ async function computeInputHash(deps, taskRepoRoot, gate, codeDiffInput, codeDif
         digest.update(coreArtifact);
         digest.update(await deps.fs.readText(resolveRepoPath(taskRepoRoot, coreArtifact)));
     }
-    const common = [
+    const common = gate === "code-diff" ? [] : [
         "CLAUDE.md",
         ".claude/agents/architect.md",
         ".claude/agents/coder.md",
@@ -1189,10 +1250,6 @@ async function computeInputHash(deps, taskRepoRoot, gate, codeDiffInput, codeDif
     if (gate === "code-diff" && codeDiffInput) {
         digest.update("codeDiffSources");
         digest.update(codeDiffSources?.join("\n") ?? "<missing>");
-        digest.update("baseCommit");
-        digest.update(codeDiffInput.baseCommit);
-        digest.update("headCommit");
-        digest.update(codeDiffInput.headCommit);
         digest.update("commits");
         digest.update(codeDiffInput.commits.join("\n"));
         digest.update("changedFiles");
@@ -1295,11 +1352,14 @@ async function readValidationReportError(fs, taskRepoRoot) {
     }
     return undefined;
 }
-async function readCodeDiffPrerequisiteError(deps, context, index, source) {
-    const reportError = await readValidationReportError(deps.fs, context.taskRepoRoot);
+async function readCodeDiffEvidenceError(fs, taskRepoRoot, source) {
+    const reportError = await readValidationReportError(fs, taskRepoRoot);
     if (reportError) {
         return "code-diff requires completed Tester validation. " + reportError;
     }
+    return readCodeDiffSourceArtifactError(fs, taskRepoRoot, source);
+}
+async function readCodeDiffValidationGateError(deps, context, index) {
     const validationGate = index.gates["validation-adequacy"];
     if (validationGate.required && validationGate.status !== "skipped" && validationGate.status !== "overridden") {
         if (validationGate.status !== "completed" || validationGate.decision !== "approve") {
@@ -1310,7 +1370,7 @@ async function readCodeDiffPrerequisiteError(deps, context, index, source) {
             return "code-diff requires a current validation-adequacy approval; code or test evidence changed after the recorded approval.";
         }
     }
-    return readCodeDiffSourceArtifactError(deps.fs, context.taskRepoRoot, source);
+    return undefined;
 }
 async function readArchitectureEvidenceError(fs, taskRepoRoot) {
     const relativePath = ".ai/vcm/handoffs/architecture-evidence.md";
@@ -1399,17 +1459,16 @@ Use each captured snapshot as the immutable handoff or prior-Gate input for this
 Code Diff Input:
 This code-diff gate reviews the new commits from one PM route flow, not the whole task and not one terminal turn.
 Code sources: ${codeDiffSources?.join(" -> ") ?? "<missing>"}
-Base commit: ${codeDiffInput.baseCommit}
-Head commit: ${codeDiffInput.headCommit}
-Commits:
+Reviewable commits:
 ${codeDiffInput.commits.map((line) => `- ${line}`).join("\n")}
 Changed files:
 ${codeDiffInput.changedFiles.length > 0 ? codeDiffInput.changedFiles.map((line) => `- ${line}`).join("\n") : "- <none>"}
 Diff commands:
-- git diff --stat --find-renames ${codeDiffInput.baseCommit}..${codeDiffInput.headCommit}
-- git diff --find-renames ${codeDiffInput.baseCommit}..${codeDiffInput.headCommit}
-- git show --stat --oneline <commit>
-Review only this commit range.`
+${codeDiffInput.commitShas.flatMap((commitSha) => [
+            `- git show --stat --oneline ${commitSha}`,
+            `- git show --find-renames ${commitSha}`
+        ]).join("\n")}
+Review only these commits.`
         : "";
     return `[VCM GATE REVIEW]
 Task: ${context.taskSlug}
@@ -1763,18 +1822,58 @@ function getSourceArtifacts(gate, codeDiffSources) {
             ...(codeDiffSources ?? []).flatMap((source) => CODE_DIFF_SOURCE_ARTIFACTS[source])
         ])];
 }
-function resolveCodeDiffSources(record, codeDiffInput, currentSource) {
+function resolveCodeDiffSources(record, codeDiffInput, currentSources) {
     const continuingRecordedRange = record.baseCommit === codeDiffInput.baseCommit
         && ((record.status === "completed" && record.decision === "request_changes")
             || record.status === "failed");
     if (!continuingRecordedRange) {
-        return [currentSource];
+        return currentSources;
     }
     return [...new Set([
             ...(normalizeCodeDiffSources(record.codeDiffSources, record.codeDiffSource) ?? []),
-            currentSource
+            ...currentSources
         ])];
 }
+async function resolveWorkflowCodeDiffSources(deps, context, currentSource) {
+    if (!deps.workflowControlService) {
+        return [currentSource];
+    }
+    try {
+        const workflowContext = {
+            taskRepoRoot: context.taskRepoRoot,
+            stateRoot: context.stateRoot,
+            handoffDir: context.handoffDir,
+            taskSlug: context.taskSlug
+        };
+        const [state, progress] = await Promise.all([
+            deps.workflowControlService.getState(workflowContext),
+            deps.workflowControlService.getProgress(workflowContext)
+        ]);
+        const startedAtSequence = state.flowRun?.startedAtSequence;
+        if (state.warnings.length > 0 || startedAtSequence === undefined) {
+            return [currentSource];
+        }
+        const sources = [];
+        for (const entry of progress.history) {
+            if (entry.sequence < startedAtSequence)
+                continue;
+            if (entry.flow === "code-change" && entry.targetRole === "coder") {
+                sources.push("coder");
+            }
+            else if (entry.flow === "architect-debug" && entry.targetRole === "architect") {
+                sources.push("architect-debug");
+            }
+            else if (entry.flow === "architecture-diagnosis" && entry.targetRole === "architect") {
+                sources.push("architect-diagnosis");
+            }
+        }
+        sources.push(currentSource);
+        return [...new Set(sources)];
+    }
+    catch {
+        return [currentSource];
+    }
+}
 function normalizeCodeDiffSources(sources, source) {
     const normalized = Array.isArray(sources) ? sources.filter(isCodeDiffSource) : [];
     if (normalized.length === 0 && isCodeDiffSource(source)) {

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

@@ -4,7 +4,6 @@ import { checkMarkdownArtifact, readArtifactSectionValue } from "../../shared/va
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
-import { getRetrospectiveReportErrors } from "./artifact-service.js";
 const FEEDBACK_ROOT = ".ai/vcm/harness-feedback";
 const PENDING_DIR = `${FEEDBACK_ROOT}/pending`;
 const TASK_RETROSPECTIVE_DIR = `${FEEDBACK_ROOT}/task-retrospectives`;
@@ -143,7 +142,7 @@ export function createHarnessFeedbackService(deps) {
             ]
             : ["Report is empty."];
         const reportReady = reportErrors.length === 0;
-        if (!reportReady || (marker.memoryRunId && !input.memoryReviewSucceeded)) {
+        if (!reportReady || (marker.memoryRunId && input.memoryReviewStatus === "failed")) {
             await persistTaskRetrospectiveMarker(repoRoot, {
                 ...marker,
                 status: "failed",
@@ -155,6 +154,41 @@ export function createHarnessFeedbackService(deps) {
             });
             return true;
         }
+        if (marker.memoryRunId && input.memoryReviewStatus === "documenting") {
+            await persistTaskRetrospectiveMarker(repoRoot, {
+                ...marker,
+                status: "waiting-docs",
+                updatedAt: timestamp
+            });
+            return true;
+        }
+        await completeTaskRetrospective(repoRoot, marker);
+        return true;
+    }
+    async function completeWaitingTaskRetrospective(repoRoot, taskSlug, memoryStatus) {
+        const marker = await loadTaskRetrospectiveMarker(repoRoot, taskSlug);
+        if (!marker || marker.status !== "waiting-docs") {
+            return false;
+        }
+        if (memoryStatus === "documenting") {
+            return true;
+        }
+        if (memoryStatus === "failed") {
+            const timestamp = now();
+            await persistTaskRetrospectiveMarker(repoRoot, {
+                ...marker,
+                status: "failed",
+                failedAt: timestamp,
+                updatedAt: timestamp,
+                error: "Task Harness Retrospective durable-document assignment failed."
+            });
+            return true;
+        }
+        await completeTaskRetrospective(repoRoot, marker);
+        return true;
+    }
+    async function completeTaskRetrospective(repoRoot, marker) {
+        const timestamp = now();
         try {
             await removeProcessedFeedback(repoRoot, marker.pendingFeedbackPaths ?? []);
         }
@@ -166,7 +200,7 @@ export function createHarnessFeedbackService(deps) {
                 updatedAt: timestamp,
                 error: `VCM could not remove processed Harness Feedback: ${errorMessage(error)}`
             });
-            return true;
+            return;
         }
         await persistTaskRetrospectiveMarker(repoRoot, {
             ...marker,
@@ -174,7 +208,6 @@ export function createHarnessFeedbackService(deps) {
             completedAt: timestamp,
             updatedAt: timestamp
         });
-        return true;
     }
     async function assertHarnessEngineerAvailable(_repoRoot) {
         return undefined;
@@ -285,6 +318,16 @@ export function createHarnessFeedbackService(deps) {
                     `Current memory snapshot: ${memoryReview.currentMemoryPath}`,
                     "Active memory files:",
                     ...memoryReview.activeMemoryPaths.map((memoryPath) => `- ${memoryPath}`),
+                    "Proposal candidates:",
+                    ...(memoryReview.proposalCandidates.length > 0
+                        ? memoryReview.proposalCandidates.map((candidate) => [
+                            candidate.id,
+                            `source=${candidate.source}`,
+                            `operation=${candidate.operation}`,
+                            `target=${candidate.target}`,
+                            `entry=${candidate.content ?? candidate.existing ?? "none"}`
+                        ].join(" | "))
+                        : ["none"]),
                     ...(memoryReview.planningCandidatePath
                         ? [`Architect planning-session candidate: ${memoryReview.planningCandidatePath}`]
                         : []),
@@ -292,88 +335,30 @@ export function createHarnessFeedbackService(deps) {
                     "Review every memory candidate against final task evidence while performing this retrospective.",
                     "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.",
-                    "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 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:",
+                    "Evaluate each proposal independently. Keep only verified, durable, reusable project knowledge; do not keep task narrative, temporary state, unverified conclusions, or Harness rules in memory.",
+                    "For every existing entry and proposal, record why the decision is necessary, the impact if the knowledge is absent, the evidence checked, and whether a durable document is the correct source.",
+                    "When the decision is move-to-durable-doc, remove the entry from memory now and add one durableDocAssignment. Do not wait for the durable document update before removing memory.",
+                    "Apply the reviewed result directly to the listed <VCM-memory> blocks. Do not change content outside those blocks.",
+                    "If memory changes, commit only the changed active memory files with message [VCM Harness] Update VCM memory. If memory is unchanged, do not create a commit.",
+                    `Write the complete machine-readable review to: ${memoryReview.reviewResultPath}`,
+                    "The JSON root must be: {\"version\":1,\"runId\":\"<assigned run id>\",\"memoryCommit\":\"<full commit or none>\",\"decisions\":[],\"durableDocAssignments\":[]}.",
+                    "Each decision must contain itemId, source (existing|proposal), target, entry, decision, reason, impactIfAbsent, evidence (non-empty array), finalContent, and durableDocPath.",
+                    "Existing decisions use retain|update|remove|move-to-durable-doc. Add or Update proposal decisions use keep-in-memory|keep-memory-reference|move-to-durable-doc|reject; Remove proposal decisions use remove|retain. Proposal itemId must equal the assigned candidate ID.",
+                    "Each durableDocAssignment must contain sourceMemoryPath, sourceEntry, targetPath, content, reason, and evidence (non-empty array). Use a project-relative Markdown target outside .ai/vcm.",
+                    "In the retrospective report, include only this memory summary:",
                     "",
                     "## Memory Review",
-                    "Existing memory reviewed: complete",
-                    "",
-                    "### Proposal Decisions",
-                    ...(memoryReview.proposalCandidates.length > 0
-                        ? memoryReview.proposalCandidates.flatMap(renderMemoryProposalDecisionTemplate)
-                        : ["none"]),
-                    "",
-                    "### Existing Memory Decisions",
-                    "#### Item 1",
-                    "Target: shared",
-                    "Existing: <exact existing memory entry>",
-                    "Decision: retain",
-                    "Reason: <why this decision is correct>",
-                    "Impact if removed: <specific future role or task failure>",
-                    "Durable doc disposition: memory",
-                    "Durable doc path: none",
-                    "Evidence: <current code, durable documentation, or final task evidence>",
-                    "",
-                    "### Existing Memory Changes",
-                    "- retained: <summary or none>",
-                    "- updated: <summary or none>",
-                    "- removed: <summary or none>",
-                    "",
-                    "Reviewed memory set: complete"
+                    "Memory commit: <full commit or none>",
+                    `Review result: ${memoryReview.reviewResultPath}`,
+                    "Durable document assignments: <count>"
                 ]
                 : []),
             "",
             `Write the analysis to Result Path: ${resolveRepoPath(repoRoot, analysisPath)}`,
-            `Submit with: .ai/tools/vcm-artifact retrospective-report --file <candidate> --path ${analysisPath} --mode final`,
-            "End your turn after VCM accepts the result."
+            "Write the report directly to that path. Do not use vcm-artifact.",
+            "End your turn after the report is complete."
         ].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]",
@@ -431,6 +416,7 @@ export function createHarnessFeedbackService(deps) {
         sendPendingFeedback,
         startTaskRetrospective,
         handleTaskRetrospectiveHook,
+        completeWaitingTaskRetrospective,
         assertHarnessEngineerAvailable
     };
 }
@@ -495,6 +481,18 @@ function assertPendingFeedbackPath(feedbackPath) {
         throw new Error(`Invalid assigned Harness Feedback path: ${feedbackPath}.`);
     }
 }
+function getRetrospectiveReportErrors(content) {
+    const errors = [];
+    if (!/^# Task Harness Retrospective(?::\s*.+)?\s*$/m.test(content)) {
+        errors.push("Retrospective report requires '# Task Harness Retrospective: <task>'.");
+    }
+    for (const heading of ["Findings", "Feedback Dispositions", "Recommended Harness Changes", "VCM Issue Drafts"]) {
+        if (!new RegExp(`^## ${heading}\\s*$`, "m").test(content)) {
+            errors.push(`Missing required section: ${heading}.`);
+        }
+    }
+    return errors;
+}
 function parseSimpleMetadata(content) {
     const result = {};
     for (const line of content.split(/\r?\n/).slice(0, 80)) {