vibe-coding-master 0.7.27 → 0.7.29

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

@@ -1014,10 +1014,12 @@ async function readArchitectureBriefError(fs, taskRepoRoot) {
     const content = await fs.readText(absolutePath);
     const check = checkMarkdownArtifact("architecture-brief", relativePath, content);
     if (check.status !== "ok") {
-        return `${relativePath} is incomplete. Complete and confirm Architect Interview before requesting architecture-plan review.`;
+        return `${relativePath} is incomplete and cannot start architecture-plan review. ${formatArtifactCheckFailure(check)}`;
     }
-    if (!/^\s*Architecture Brief Status\s*:\s*confirmed\s*$/im.test(content)) {
-        return `${relativePath} is not confirmed. Obtain explicit user confirmation before architecture planning.`;
+    const status = /^\s*Architecture Brief Status\s*:\s*(.+?)\s*$/im.exec(content)?.[1]?.trim();
+    if (status?.toLowerCase() !== "confirmed") {
+        return `${relativePath} is not confirmed and cannot start architecture-plan review. `
+            + `Architecture Brief Status must be exactly "confirmed"; found ${renderFoundValue(status)}.`;
     }
     return undefined;
 }
@@ -1032,12 +1034,8 @@ async function readValidationReportError(fs, taskRepoRoot) {
     if (check.status === "ok") {
         return undefined;
     }
-    const details = [
-        check.missingHeadings.length > 0 ? `missing headings: ${check.missingHeadings.join(", ")}` : "",
-        check.invalidFields.length > 0 ? check.invalidFields.join(" ") : "",
-        check.hasPlaceholder ? "contains placeholders" : ""
-    ].filter(Boolean).join("; ");
-    return `${relativePath} is incomplete and cannot start validation-adequacy review.${details ? ` ${details}` : ""}`;
+    return `${relativePath} is incomplete and cannot start validation-adequacy review. `
+        + formatValidationArtifactFailure(check, content);
 }
 async function readArchitectureEvidenceError(fs, taskRepoRoot) {
     const relativePath = ".ai/vcm/handoffs/architecture-evidence.md";
@@ -1049,8 +1047,10 @@ async function readArchitectureEvidenceError(fs, taskRepoRoot) {
     if (content.trim().length === 0) {
         return `${relativePath} is empty. Complete architecture evidence before requesting architecture-plan review.`;
     }
-    if (!/^\s*Architecture Evidence Status\s*:\s*complete\s*$/im.test(content)) {
-        return `${relativePath} is incomplete. Finish current-worktree evidence before requesting architecture-plan review.`;
+    const status = /^\s*Architecture Evidence Status\s*:\s*(.+?)\s*$/im.exec(content)?.[1]?.trim();
+    if (status?.toLowerCase() !== "complete") {
+        return `${relativePath} is incomplete and cannot start architecture-plan review. `
+            + `Architecture Evidence Status must be exactly "complete"; found ${renderFoundValue(status)}.`;
     }
     return undefined;
 }
@@ -1260,18 +1260,35 @@ async function validateValidationApprovalInput(fs, taskRepoRoot) {
     if (check.status === "ok") {
         return;
     }
-    const details = [
-        `status=${check.status}`,
-        check.missingHeadings.length > 0 ? `missing headings: ${check.missingHeadings.join(", ")}` : "",
-        check.invalidFields.length > 0 ? check.invalidFields.join(" ") : "",
-        check.hasPlaceholder ? "contains placeholders" : ""
-    ].filter(Boolean).join("; ");
     throw new VcmError({
         code: "GATE_REVIEW_VALIDATION_INPUT_INCOMPLETE",
-        message: `Validation-adequacy cannot approve incomplete Tester evidence in ${relativePath}. ${details}`,
+        message: `Validation-adequacy cannot approve incomplete Tester evidence in ${relativePath}. `
+            + formatValidationArtifactFailure(check, content),
         statusCode: 500
     });
 }
+function formatValidationArtifactFailure(check, content) {
+    return /^\s*Test Result\s*:\s*incomplete\s*$/im.test(content ?? "")
+        ? 'Test Result must be exactly one of "pass|fail"; found "incomplete".'
+        : formatArtifactCheckFailure(check);
+}
+function formatArtifactCheckFailure(check) {
+    const details = [
+        check.status === "missing" ? "Artifact is missing." : "",
+        check.status === "empty" ? "Artifact is empty." : "",
+        check.missingHeadings.length > 0
+            ? `Missing headings: ${check.missingHeadings.join(", ")}.`
+            : "",
+        ...check.invalidFields,
+        check.hasPlaceholder ? "Replace every standalone TBD, Not run yet, or draft-status placeholder." : ""
+    ].filter(Boolean);
+    return details.length > 0
+        ? details.join(" ")
+        : "Artifact is not in a gate-ready terminal state.";
+}
+function renderFoundValue(value) {
+    return value && value.trim().length > 0 ? JSON.stringify(value.trim()) : "<missing>";
+}
 function validateRequestChangeFindings(findings) {
     if (findings.length === 0) {
         throw new VcmError({

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

@@ -49,7 +49,7 @@ export function createHarnessFeedbackService(deps) {
             });
         }
         const existingMarker = await loadTaskRetrospectiveMarker(repoRoot, taskSlug);
-        if (existingMarker) {
+        if (existingMarker && existingMarker.status !== "failed") {
             throw new VcmError({
                 code: "TASK_HARNESS_RETROSPECTIVE_EXISTS",
                 message: `Task Harness Retrospective has already been triggered for task: ${taskSlug}`,
@@ -77,19 +77,82 @@ export function createHarnessFeedbackService(deps) {
         const session = await ensureIdleHarnessEngineer(repoRoot, taskSlug);
         const timestamp = now();
         const analysisPath = `${TASK_RETROSPECTIVE_DIR}/${sanitizeFeedbackId(taskSlug)}.md`;
-        await persistTaskRetrospectiveMarker(repoRoot, {
+        const analysisAbsolutePath = resolveRepoPath(repoRoot, analysisPath);
+        const memoryReview = await deps.autoMemoryService?.prepareTaskRetrospectiveReview(input.taskRepoRoot, analysisAbsolutePath);
+        const marker = {
             version: 1,
             taskSlug,
             trigger: input.trigger,
-            status: "triggered",
+            status: "running",
             analysisPath,
             finalAcceptanceHash: `sha256:${sha256(finalAcceptanceContent)}`,
+            ...(memoryReview ? { memoryRunId: memoryReview.runId } : {}),
             createdAt: timestamp,
             updatedAt: timestamp
-        });
-        await submitTerminalInput(deps.runtime, session.id, buildTaskRetrospectivePrompt(repoRoot, analysisPath));
+        };
+        const pendingFeedback = await listPendingFeedback(repoRoot);
+        try {
+            await persistTaskRetrospectiveMarker(repoRoot, marker);
+            await submitTerminalInput(deps.runtime, session.id, buildTaskRetrospectivePrompt(repoRoot, analysisPath, pendingFeedback.map((item) => item.path), memoryReview));
+        }
+        catch (error) {
+            if (memoryReview) {
+                await deps.autoMemoryService?.cancelTaskRetrospectiveReview(input.taskRepoRoot, memoryReview.runId);
+            }
+            const failedAt = now();
+            await persistTaskRetrospectiveMarker(repoRoot, {
+                ...marker,
+                status: "failed",
+                failedAt,
+                updatedAt: failedAt,
+                error: errorMessage(error)
+            });
+            throw error;
+        }
         return getState(repoRoot);
     }
+    async function handleTaskRetrospectiveHook(repoRoot, input) {
+        const marker = await loadTaskRetrospectiveMarker(repoRoot, input.taskSlug);
+        if (!marker || (marker.status !== "running" && marker.status !== "triggered")) {
+            return false;
+        }
+        if (input.eventName === "UserPromptSubmit" || input.eventName === "PostCompact") {
+            return true;
+        }
+        const timestamp = now();
+        if (input.eventName === "StopFailure") {
+            await persistTaskRetrospectiveMarker(repoRoot, {
+                ...marker,
+                status: "failed",
+                failedAt: timestamp,
+                updatedAt: timestamp,
+                error: "Harness Engineer Task Harness Retrospective turn failed."
+            });
+            return true;
+        }
+        const reportPath = resolveRepoPath(repoRoot, marker.analysisPath);
+        const reportReady = await deps.fs.pathExists(reportPath)
+            && Boolean((await deps.fs.readText(reportPath)).trim());
+        if (!reportReady || (marker.memoryRunId && !input.memoryReviewSucceeded)) {
+            await persistTaskRetrospectiveMarker(repoRoot, {
+                ...marker,
+                status: "failed",
+                failedAt: timestamp,
+                updatedAt: timestamp,
+                error: !reportReady
+                    ? "Harness Engineer did not write the required Task Harness Retrospective report."
+                    : "Task Harness Retrospective memory review failed."
+            });
+            return true;
+        }
+        await persistTaskRetrospectiveMarker(repoRoot, {
+            ...marker,
+            status: "completed",
+            completedAt: timestamp,
+            updatedAt: timestamp
+        });
+        return true;
+    }
     async function assertHarnessEngineerAvailable(_repoRoot) {
         return undefined;
     }
@@ -162,12 +225,76 @@ export function createHarnessFeedbackService(deps) {
             summary: metadata.summary
         };
     }
-    function buildTaskRetrospectivePrompt(repoRoot, analysisPath) {
+    function buildTaskRetrospectivePrompt(repoRoot, analysisPath, pendingFeedbackPaths, memoryReview) {
+        const pendingFeedback = pendingFeedbackPaths.length > 0
+            ? pendingFeedbackPaths.map((feedbackPath) => `- ${resolveRepoPath(repoRoot, feedbackPath)}`)
+            : ["none"];
         return [
             "[VCM Task Harness Retrospective]",
             "",
             "Review the completed task from the current active task worktree.",
             "",
+            `Pending Feedback Directory: ${resolveRepoPath(repoRoot, PENDING_DIR)}`,
+            "",
+            "Pending Feedback:",
+            ...pendingFeedback,
+            ...(pendingFeedbackPaths.length > 0
+                ? [
+                    "",
+                    "Process every listed feedback inside this retrospective. Record every disposition in the retrospective report, then delete the processed feedback files before ending the turn."
+                ]
+                : []),
+            ...(memoryReview
+                ? [
+                    "",
+                    "Auto Memory Review:",
+                    `Role drafts: ${memoryReview.roleDraftsPath}`,
+                    `Current memory snapshot: ${memoryReview.currentMemoryPath}`,
+                    ...(memoryReview.planningCandidatePath
+                        ? [`Architect planning-session candidate: ${memoryReview.planningCandidatePath}`]
+                        : []),
+                    `Write the complete reviewed memory set to: ${memoryReview.reviewedMemoryPath}`,
+                    "",
+                    "Review every memory candidate against final task evidence while performing this retrospective.",
+                    "Each snapshot file contains only the matching <VCM-memory> block content. Edit every existing reviewed-memory file in place.",
+                    "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.",
+                    "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.",
+                    "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.",
+                    "Use this exact block in the retrospective report and replace each option or placeholder with one allowed value or a concise summary:",
+                    "",
+                    "## Memory Review",
+                    "Existing memory reviewed: complete",
+                    "",
+                    "### Proposal Dispositions",
+                    ...memoryReview.proposalRoles.map((role) => `- ${role}: accepted|rejected|no-change`),
+                    "",
+                    "### 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"
+                ]
+                : []),
+            "",
             `Write the analysis to Result Path: ${resolveRepoPath(repoRoot, analysisPath)}`,
             "End your turn after writing the result."
         ].join("\n");
@@ -190,7 +317,7 @@ export function createHarnessFeedbackService(deps) {
         return deps.fs.readJson(markerPath);
     }
     async function persistTaskRetrospectiveMarker(repoRoot, marker) {
-        const markerPath = resolveRepoPath(repoRoot, getTaskRetrospectiveMarkerPath(String(marker.taskSlug ?? "")));
+        const markerPath = resolveRepoPath(repoRoot, getTaskRetrospectiveMarkerPath(marker.taskSlug));
         await deps.fs.ensureDir(path.dirname(markerPath));
         await deps.fs.writeJsonAtomic(markerPath, marker);
     }
@@ -214,6 +341,7 @@ export function createHarnessFeedbackService(deps) {
         getState,
         sendPendingFeedback,
         startTaskRetrospective,
+        handleTaskRetrospectiveHook,
         assertHarnessEngineerAvailable
     };
 }
@@ -245,3 +373,6 @@ function sanitizeFeedbackId(value) {
 function sha256(content) {
     return createHash("sha256").update(content).digest("hex");
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -0,0 +1,80 @@
+const OPERATIONS = ["Add", "Update", "Remove"];
+export function validateMemoryProposal(content) {
+    if (!/^# Memory Proposal\s*$/m.test(content)) {
+        return "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";
+    }
+    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";
+    }
+    let itemCount = 0;
+    for (let index = 0; index < sections.length; index += 1) {
+        const section = sections[index];
+        const operation = section[1];
+        const bodyStart = (section.index ?? 0) + section[0].length;
+        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;
+        }
+        itemCount += result;
+    }
+    const decision = decisionMatches[0][1];
+    if (decision === "no-change" && itemCount !== 0) {
+        return "uses Decision: no-change but contains a memory item";
+    }
+    if (decision === "update" && itemCount === 0) {
+        return "uses Decision: update without a structured memory item";
+    }
+    return undefined;
+}
+function validateOperationBody(operation, rawBody) {
+    const body = rawBody.trim();
+    if (body === "none") {
+        return 0;
+    }
+    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`;
+    }
+    for (let index = 0; index < itemHeadings.length; index += 1) {
+        const heading = itemHeadings[index];
+        const itemStart = (heading.index ?? 0) + heading[0].length;
+        const itemEnd = index + 1 < itemHeadings.length
+            ? itemHeadings[index + 1].index ?? body.length
+            : body.length;
+        const item = body.slice(itemStart, itemEnd).trim();
+        const expectedPattern = operation === "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"
+                ? /^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"
+                ? "Target, Content, Reason, Impact if absent, Durable doc disposition, Durable doc path, and Evidence"
+                : operation === "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`;
+        }
+        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`;
+            }
+        }
+    }
+    return itemHeadings.length;
+}

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

@@ -0,0 +1,7 @@
+export const MEMORY_REVIEW_ROOT = ".ai/vcm/memory-review";
+export const MEMORY_REVIEW_RUNS_ROOT = `${MEMORY_REVIEW_ROOT}/runs`;
+export const MEMORY_REVIEW_STATE_PATH = `${MEMORY_REVIEW_ROOT}/state.json`;
+export const ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH = `${MEMORY_REVIEW_ROOT}/candidates/architect/planning.md`;
+export function architectPlanningCandidateSnapshotPath(runId) {
+    return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/sources/architect-planning.md`;
+}

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

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

package/dist/backend/templates/handoff.js

@@ -1,7 +1,8 @@
+import { ARCHITECTURE_BRIEF_STATUSES, ARCHITECTURE_PLAN_RESULTS, DOCS_SYNC_DECISIONS, FINAL_ACCEPTANCE_DECISIONS, L3_ACTIONS, L3_REQUIRED_VALUES, STRICT_NONE_VALUE, TEST_RESULTS, renderArtifactOptions } from "../../shared/validation/artifact-contract.js";
 export function renderArchitectureBriefTemplate(taskSlug) {
     return `# Architecture Brief: ${taskSlug}
 
-Architecture Brief Status: interviewing|confirmed
+Architecture Brief Status: ${renderArtifactOptions(ARCHITECTURE_BRIEF_STATUSES)}
 
 ## Accepted Outcome
 
@@ -17,7 +18,7 @@ TBD
 
 ## Unresolved User Decisions
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## User Confirmation
 
@@ -27,7 +28,7 @@ TBD
 export function renderArchitecturePlanTemplate(taskSlug) {
     return `# Architecture Plan: ${taskSlug}
 
-Planning Result: complete|incomplete|user clarification required
+Planning Result: ${renderArtifactOptions(ARCHITECTURE_PLAN_RESULTS)}
 
 ## Accepted Scope
 
@@ -100,10 +101,13 @@ TBD
 Task-specific context and coder guidance go here, not in source-code comments.
 Source-code comments should only describe durable behavior, contracts, invariants,
 error boundaries, or non-obvious logic that should remain useful after this task.
+Use an ID matching \`[A-Z]{2,6}-[0-9]{1,4}\`, choose exactly one Action
+(\`create\`, \`change\`, or \`delete\`), put the repo-relative File path in
+backticks, and enumerate every implementation item explicitly.
 
 | ID | Action | File | Symbol Or Site | Coder Work | Allowed Implementation Freedom | Behavior / Contract Proof Point |
 | --- | --- | --- | --- | --- | --- | --- |
-| TBD | TBD | TBD | TBD | TBD | TBD | TBD |
+| <ID> | <create|change|delete> | \`<repo-relative-file>\` | TBD | TBD | TBD | TBD |
 
 ## Scaffold Build Evidence
 
@@ -143,7 +147,7 @@ At task close, promote still-relevant confirmed issues to \`docs/known-issues.md
 export function renderTestReportTemplate(taskSlug) {
     return `# Test Report: ${taskSlug}
 
-Test Result: pass|fail|incomplete
+Test Result: ${renderArtifactOptions(TEST_RESULTS)}
 
 ## Evidence Reviewed
 
@@ -165,11 +169,11 @@ TBD
 
 ### Remaining Validation
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## L3 Coverage
 
-L3 Required: yes|no
+L3 Required: ${renderArtifactOptions(L3_REQUIRED_VALUES)}
 
 ### Trigger Assessment
 
@@ -179,7 +183,7 @@ TBD
 
 | Flow | Trigger | Case ID | Test File | Entry Point | Final Observable Result | Action | Result |
 | --- | --- | --- | --- | --- | --- | --- | --- |
-| TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD |
+| TBD | TBD | TBD | TBD | TBD | TBD | <${renderArtifactOptions(L3_ACTIONS)}> | TBD |
 
 ### L3 Commands And Evidence
 
@@ -199,27 +203,27 @@ TBD
 
 ## Failed Expectations
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## Reproduction Steps
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## Skipped Checks With Reasons
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## Coverage Gaps
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## Blocking Validation Issues
 
-TBD
+${STRICT_NONE_VALUE}
 
 ## User Approval Evidence
 
-TBD
+${STRICT_NONE_VALUE}
 `;
 }
 export function renderCoderCompletionTemplate(taskSlug) {
@@ -348,7 +352,7 @@ TBD
 
 ## Decision
 
-TBD
+${renderArtifactOptions(DOCS_SYNC_DECISIONS)}
 `;
 }
 export function renderFinalAcceptanceTemplate(taskSlug) {
@@ -356,7 +360,7 @@ export function renderFinalAcceptanceTemplate(taskSlug) {
 
 ## Decision
 
-TBD
+${renderArtifactOptions(FINAL_ACCEPTANCE_DECISIONS)}
 
 ## Evidence Reviewed
 

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

@@ -78,7 +78,7 @@ ${renderRoleMemoryRules("architect")}
 - \`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.
 - \`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. An item is one of: a created body or surface (\`create\`), one required change site — one contiguous edit region inside an existing body or surface (\`change\`), or one deletion of a body, site, or file (\`delete\`). An item not in the ledger is not in the plan; coder must not implement it.
+- \`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.
 - Each ledger entry carries, in this column order: a unique stable ID such as \`SCF-001\`, action, exact file path, symbol or site, coder work, allowed implementation freedom, and a behavior/contract proof point. Per-file evidence, why-in-scope, and durable-comment needs live in the Module/File Plan, not in the ledger. Open-ended coverage language ("as work proceeds", "replicate", "etc.", "and others") is forbidden anywhere in the ledger.
 - IDs and markers correspond one to one: every \`create\`, \`change\`, and \`delete\` entry has exactly one \`VCM:CODE <ID>\` marker pre-placed at its declared file and site; a \`delete\` marker sits on the code to be removed and leaves with it.
 - The Scaffold Manifest is complete only when the ledger ID set and the tree's \`VCM:CODE\` ID set are equal, each ID appears exactly once on each side, and each marker sits in its declared file (\`.ai/tools/check-scaffold-ledger\` automates the check). Any mismatch means the plan is not complete.
@@ -116,7 +116,8 @@ ${renderRoleMemoryRules("architect")}
 #### Planning Completion
 
 - After the complete plan, scaffold, reconciliation, L0 evidence, and commits are ready, use the \`restart-architect\` skill before writing the completed Architect-to-PM route message.
-- After VCM reports the restart is scheduled, write the route message with both architecture artifacts and the plan, then end the turn. VCM keeps this session for any architecture-plan Gate revision and restarts it only after the Gate is accepted. Do not wait for or inspect the replacement session.
+- If VCM returns a \`memoryCandidatePath\`, use \`vcm-propose-memory\` to write the planning-session memory candidate to that path before routing. Include only verified, durable, reusable project knowledge from planning; do not record task narrative, temporary state, unverified conclusions, or Harness rules.
+- After the required candidate is written, write the route message with both architecture artifacts and the plan, then end the turn. VCM keeps this session for any architecture-plan Gate revision and restarts it only after the Gate is accepted. Do not wait for or inspect the replacement session.
 
 ### Complete Task Planning
 

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

@@ -7,7 +7,7 @@ export function renderRootClaudeHarnessRules() {
 - Project-manager uses \`vcm-task-state\` to declare the current workflow checkpoint. This state is recoverable context only; flow rules and task artifacts remain authoritative.
 - Use \`vcm-long-running-validation\` for long-running validation. Follow the background job limits below.
 - Use \`vcm-report-harness-issue\` when you notice a reusable VCM harness problem. Record feedback; do not contact Harness Engineer directly.
-- The root \`<VCM-memory>\` block is shared project memory. Treat every \`<VCM-memory>\` block as read-only and use \`vcm-propose-memory\` only when VCM assigns a memory proposal during Task Harness Review.
+- The root \`<VCM-memory>\` block is shared project memory. Treat every \`<VCM-memory>\` block as read-only and use \`vcm-propose-memory\` only when VCM assigns an exact memory proposal or candidate path.
 - Only the user may approve scope reduction, skipped required validation, Gate Review skip or override, skipped required docs sync, accepted unresolved task-scope risk, or weakening of baseline Harness rules. PM may record and route the user's approval but cannot grant it.
 - Project-manager runs \`vcm-gate-review\` unconditionally at every Gate Review trigger point and on VCM Gate Review callbacks; the tool reports the authoritative enable state.
 

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

@@ -46,7 +46,18 @@ ${renderRoleMemoryRules("coder")}
 - Use workers when the task has at least 20 \`VCM:CODE\` markers and the marker distribution can form at least two worker-sized groups.
 - Under a complete scaffold, marker implementations are order-independent — signatures, types, and cross-item contracts are frozen by the scaffold — so never serialize worker-sized groups for presumed implementation-order dependencies. When a group's module-scoped checks need peers that are still unimplemented, narrow that worker's assigned validation scope instead of serializing.
 - An item counts as blocked only when a genuine implementation attempt has produced objective compile/check evidence already reported under the failure rules; prediction never blocks an item. A blocked marker item never exempts the remaining markers from worker dispatch.
-- Before invoking workers, count \`VCM:CODE\` markers by module and create one runtime state file per worker under \`.ai/vcm/coder-workers/tasks/<worker-id>.json\` with \`status: running\`.
+- Before invoking workers, count \`VCM:CODE\` markers by module and create one runtime state file per worker under \`.ai/vcm/coder-workers/tasks/<worker-id>.json\` with exactly this initial shape:
+
+\`\`\`json
+{
+  "workerId": "<worker-id>",
+  "status": "running",
+  "reportPath": ".ai/vcm/coder-workers/reports/<worker-id>.md",
+  "handled": false
+}
+\`\`\`
+
+- After a worker completes, its state must retain those fields, set \`status\` to \`completed\`, and add the exact \`commitHash\` from its report. Only Coder changes \`handled\` to \`true\` after inspecting that report and commit.
 - Create one worker task for each module with more than 10 \`VCM:CODE\` markers.
 - Group modules with 10 or fewer \`VCM:CODE\` markers into one small-modules worker when their combined marker count is more than 10.
 - If the combined small-module marker count is 10 or fewer, Coder handles those modules directly after worker results return.