vibe-coding-master 0.7.42 → 0.7.44

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`;
@@ -76,6 +75,7 @@ export function createHarnessFeedbackService(deps) {
             });
         }
         const session = await ensureIdleHarnessEngineer(repoRoot, taskSlug);
+        const pendingFeedback = await listPendingFeedback(repoRoot);
         const timestamp = now();
         const analysisPath = `${TASK_RETROSPECTIVE_DIR}/${sanitizeFeedbackId(taskSlug)}.md`;
         const analysisAbsolutePath = resolveRepoPath(repoRoot, analysisPath);
@@ -87,11 +87,11 @@ export function createHarnessFeedbackService(deps) {
             status: "running",
             analysisPath,
             finalAcceptanceHash: `sha256:${sha256(finalAcceptanceContent)}`,
+            pendingFeedbackPaths: pendingFeedback.map((item) => item.path),
             ...(memoryReview ? { memoryRunId: memoryReview.runId } : {}),
             createdAt: timestamp,
             updatedAt: timestamp
         };
-        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));
@@ -135,9 +135,14 @@ export function createHarnessFeedbackService(deps) {
         const reportContent = await deps.fs.pathExists(reportPath)
             ? await deps.fs.readText(reportPath)
             : "";
-        const reportErrors = reportContent.trim() ? getRetrospectiveReportErrors(reportContent) : ["Report is empty."];
+        const reportErrors = reportContent.trim()
+            ? [
+                ...getRetrospectiveReportErrors(reportContent),
+                ...getFeedbackDispositionErrors(repoRoot, marker.pendingFeedbackPaths ?? [], reportContent)
+            ]
+            : ["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",
@@ -149,13 +154,60 @@ 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 ?? []);
+        }
+        catch (error) {
+            await persistTaskRetrospectiveMarker(repoRoot, {
+                ...marker,
+                status: "failed",
+                failedAt: timestamp,
+                updatedAt: timestamp,
+                error: `VCM could not remove processed Harness Feedback: ${errorMessage(error)}`
+            });
+            return;
+        }
         await persistTaskRetrospectiveMarker(repoRoot, {
             ...marker,
             status: "completed",
             completedAt: timestamp,
             updatedAt: timestamp
         });
-        return true;
     }
     async function assertHarnessEngineerAvailable(_repoRoot) {
         return undefined;
@@ -245,7 +297,15 @@ export function createHarnessFeedbackService(deps) {
             ...(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."
+                    "Process every listed feedback inside this retrospective. Record every disposition in the retrospective report using this exact block for each assigned path:",
+                    "",
+                    "### Feedback: <exact assigned absolute path>",
+                    "Decision: confirmed|rejected|duplicate|already-covered",
+                    "Evidence: <concise evidence>",
+                    "Impact: <impact>",
+                    "Required action: <action or none>",
+                    "",
+                    "Do not edit or delete pending feedback files. VCM removes the assigned files after validating every disposition in the accepted report."
                 ]
                 : []),
             "",
@@ -258,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}`]
                         : []),
@@ -265,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]",
@@ -375,6 +387,20 @@ export function createHarnessFeedbackService(deps) {
             await deps.fs.removePath?.(statePath, { force: true });
         }
     }
+    async function removeProcessedFeedback(repoRoot, feedbackPaths) {
+        if (feedbackPaths.length === 0) {
+            return;
+        }
+        if (!deps.fs.removePath) {
+            throw new Error("The filesystem adapter does not support feedback removal.");
+        }
+        for (const feedbackPath of feedbackPaths) {
+            assertPendingFeedbackPath(feedbackPath);
+        }
+        for (const feedbackPath of feedbackPaths) {
+            await deps.fs.removePath(resolveRepoPath(repoRoot, feedbackPath), { force: true });
+        }
+    }
     async function readOptionalText(repoRoot, relativePath) {
         const absolutePath = resolveRepoPath(repoRoot, relativePath);
         return readAbsoluteOptionalText(absolutePath);
@@ -390,9 +416,83 @@ export function createHarnessFeedbackService(deps) {
         sendPendingFeedback,
         startTaskRetrospective,
         handleTaskRetrospectiveHook,
+        completeWaitingTaskRetrospective,
         assertHarnessEngineerAvailable
     };
 }
+function getFeedbackDispositionErrors(repoRoot, feedbackPaths, reportContent) {
+    if (feedbackPaths.length === 0) {
+        return [];
+    }
+    const section = readLevelTwoSection(reportContent, "Feedback Dispositions");
+    if (!section) {
+        return ["Feedback Dispositions is empty."];
+    }
+    const errors = [];
+    const lines = section.split(/\r?\n/);
+    for (const feedbackPath of feedbackPaths) {
+        try {
+            assertPendingFeedbackPath(feedbackPath);
+        }
+        catch (error) {
+            errors.push(errorMessage(error));
+            continue;
+        }
+        const absolutePath = resolveRepoPath(repoRoot, feedbackPath);
+        const heading = `### Feedback: ${absolutePath}`;
+        const start = lines.findIndex((line) => line.trim() === heading);
+        if (start < 0) {
+            errors.push(`Missing disposition for assigned feedback: ${absolutePath}.`);
+            continue;
+        }
+        const endOffset = lines.slice(start + 1).findIndex((line) => /^###\s+/.test(line.trim()));
+        const end = endOffset < 0 ? lines.length : start + 1 + endOffset;
+        const block = lines.slice(start + 1, end);
+        const decision = readDispositionField(block, "Decision");
+        if (!decision || !["confirmed", "rejected", "duplicate", "already-covered"].includes(decision)) {
+            errors.push(`Feedback disposition Decision for ${absolutePath} must be confirmed|rejected|duplicate|already-covered.`);
+        }
+        for (const field of ["Evidence", "Impact", "Required action"]) {
+            if (!readDispositionField(block, field)) {
+                errors.push(`Feedback disposition ${field} is required for ${absolutePath}.`);
+            }
+        }
+    }
+    return errors;
+}
+function readLevelTwoSection(content, heading) {
+    const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = new RegExp(`^##\\s+${escapedHeading}\\s*$`, "im").exec(content);
+    if (!match || match.index === undefined) {
+        return undefined;
+    }
+    const afterHeading = content.slice(match.index + match[0].length);
+    const nextHeading = /\n##\s+\S/.exec(afterHeading);
+    return (nextHeading ? afterHeading.slice(0, nextHeading.index) : afterHeading).trim();
+}
+function readDispositionField(lines, field) {
+    const escapedField = field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return lines
+        .map((line) => new RegExp(`^${escapedField}:\\s*(.+)$`, "i").exec(line.trim())?.[1]?.trim())
+        .find((value) => Boolean(value));
+}
+function assertPendingFeedbackPath(feedbackPath) {
+    if (!/^\.ai\/vcm\/harness-feedback\/pending\/[A-Za-z0-9._-]+\.md$/.test(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)) {

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

@@ -25,10 +25,12 @@ import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/v
 import { renderVcmProposeMemorySkillRules } from "../templates/harness/vcm-propose-memory-skill.js";
 import { renderVcmReportHarnessIssueSkillRules } from "../templates/harness/vcm-report-harness-issue-skill.js";
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-skill.js";
+import { renderAskUserTool, renderVcmAskUserSkillRules } from "../templates/harness/vcm-ask-user-skill.js";
 import { renderUpdateTaskStateTool, renderVcmTaskStateSkillRules } from "../templates/harness/vcm-task-state-skill.js";
 import { renderVcmWorkflowReviewSkillRules } from "../templates/harness/vcm-workflow-review-skill.js";
 import { renderCheckScaffoldLedgerTool } from "../templates/harness/check-scaffold-ledger.js";
 import { renderRequestArchitectRestartTool, renderRestartArchitectSkillRules } from "../templates/harness/restart-architect-skill.js";
+import { renderResolveDurableDocAssignmentTool } from "../templates/harness/resolve-durable-doc-assignment.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { VcmError } from "../errors.js";
 import { bumpHarnessRevision, readHarnessRevisionState } from "./harness-revision.js";
@@ -57,8 +59,15 @@ const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "PreToolUse", matcher: "Write|Edit", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PreToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostToolUseFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostToolBatch", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "SubagentStart", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "SubagentStop", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PreCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PostCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];
@@ -119,7 +128,7 @@ const HARNESS_FILES = [
         kind: "skill-vcm-code-navigation",
         path: ".claude/skills/vcm-code-navigation/SKILL.md",
         title: "VCM Code Navigation Skill",
-        frontmatter: renderSkillFrontmatter("vcm-code-navigation", "Use when Architect, Coder, or Reviewer must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths."),
+        frontmatter: renderSkillFrontmatter("vcm-code-navigation", "Use when Architect must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths."),
         ownership: "whole-file",
         renderRules: renderVcmCodeNavigationSkillRules
     },
@@ -131,6 +140,14 @@ const HARNESS_FILES = [
         ownership: "whole-file",
         renderRules: renderVcmRouteMessageSkillRules
     },
+    {
+        kind: "skill-vcm-ask-user",
+        path: ".claude/skills/vcm-ask-user/SKILL.md",
+        title: "VCM Ask User Skill",
+        frontmatter: renderSkillFrontmatter("vcm-ask-user", "Use whenever project-manager asks the user a question and must pause the workflow."),
+        ownership: "whole-file",
+        renderRules: renderVcmAskUserSkillRules
+    },
     {
         kind: "skill-vcm-task-state",
         path: ".claude/skills/vcm-task-state/SKILL.md",
@@ -209,8 +226,8 @@ const HARNESS_FILES = [
         title: "Reviewer Agent",
         memoryBlock: true,
         requiredDisallowedTools: REVIEWER_DISALLOWED_TOOLS,
-        requiredSkills: ["vcm-code-navigation"],
-        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { disallowedTools: REVIEWER_DISALLOWED_TOOLS.join(", "), skills: ["vcm-code-navigation"] }),
+        removedSkills: ["vcm-code-navigation"],
+        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { disallowedTools: REVIEWER_DISALLOWED_TOOLS.join(", ") }),
         renderRules: renderReviewerAgentRules
     },
     {
@@ -250,6 +267,13 @@ const HARNESS_FILES = [
         ownership: "raw-file",
         renderRules: renderRequestGateReviewTool
     },
+    {
+        kind: "tool-vcm-ask-user",
+        path: ".ai/tools/vcm-ask-user",
+        title: "VCM Ask User Tool",
+        ownership: "raw-file",
+        renderRules: renderAskUserTool
+    },
     {
         kind: "tool-update-task-state",
         path: ".ai/tools/update-task-state",
@@ -271,6 +295,13 @@ const HARNESS_FILES = [
         ownership: "raw-file",
         renderRules: renderRequestArchitectRestartTool
     },
+    {
+        kind: "tool-resolve-durable-doc-assignment",
+        path: ".ai/tools/resolve-durable-doc-assignment",
+        title: "Resolve Durable Documentation Assignment Tool",
+        ownership: "raw-file",
+        renderRules: renderResolveDurableDocAssignmentTool
+    },
     {
         kind: "agent-project-manager",
         path: ".claude/agents/project-manager.md",
@@ -297,8 +328,8 @@ const HARNESS_FILES = [
         title: "Coder Agent",
         memoryBlock: true,
         requiredDisallowedTools: CODE_ROLE_DISALLOWED_TOOLS,
-        requiredSkills: ["vcm-code-navigation"],
-        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { disallowedTools: CODE_ROLE_DISALLOWED_TOOLS.join(", "), skills: ["vcm-code-navigation"] }),
+        removedSkills: ["vcm-code-navigation"],
+        frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { disallowedTools: CODE_ROLE_DISALLOWED_TOOLS.join(", ") }),
         renderRules: renderCoderHarnessRules
     },
     {
@@ -353,7 +384,7 @@ export function createHarnessService(deps) {
             let harnessCommit;
             if (nextContent !== currentContent) {
                 await bumpHarnessRevision(deps.fs, repoRoot, now());
-                harnessCommit = (await commitHarnessVisibleChanges(deps.git, repoRoot, "chore(vcm-harness): update harness file")).harnessCommit;
+                harnessCommit = (await commitHarnessVisibleChanges(deps.git, repoRoot, "[VCM Harness] Update harness file")).harnessCommit;
             }
             const file = await readHarnessFileContent(deps.fs, repoRoot, definition.path);
             const [analyses, codeIntelligence] = await Promise.all([
@@ -377,7 +408,7 @@ export function createHarnessService(deps) {
                 if (result.changedFiles.length > 0) {
                     await bumpHarnessRevision(deps.fs, repoRoot, now());
                 }
-                const committed = await commitHarnessVisibleChanges(deps.git, repoRoot, "chore(vcm-harness): update fixed harness");
+                const committed = await commitHarnessVisibleChanges(deps.git, repoRoot, "[VCM Harness] Update fixed harness");
                 return {
                     ...result,
                     changedFiles: committed.changedFiles.length > 0 ? committed.changedFiles : result.changedFiles,
@@ -401,7 +432,7 @@ export function createHarnessService(deps) {
             if (changedFiles.length > 0) {
                 await bumpHarnessRevision(deps.fs, repoRoot, now());
             }
-            const committed = await commitHarnessVisibleChanges(deps.git, repoRoot, "chore(vcm-harness): update fixed harness");
+            const committed = await commitHarnessVisibleChanges(deps.git, repoRoot, "[VCM Harness] Update fixed harness");
             return {
                 version: VCM_HARNESS_VERSION,
                 changedFiles: committed.changedFiles.length > 0 ? committed.changedFiles : changedFiles,
@@ -1444,7 +1475,8 @@ function ensureAgentAllowedTool(content, requiredTool) {
 function normalizeAgentFrontmatter(content, definition) {
     const allowedToolsUpdated = (definition.requiredTools ?? []).reduce(ensureAgentAllowedTool, content);
     const disallowedToolsUpdated = ensureAgentDisallowedTools(allowedToolsUpdated, definition.requiredDisallowedTools);
-    return (definition.requiredSkills ?? []).reduce(ensureAgentSkill, disallowedToolsUpdated);
+    const skillsUpdated = (definition.requiredSkills ?? []).reduce(ensureAgentSkill, disallowedToolsUpdated);
+    return (definition.removedSkills ?? []).reduce(removeAgentSkill, skillsUpdated);
 }
 function ensureAgentSkill(content, requiredSkill) {
     const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
@@ -1466,6 +1498,30 @@ function ensureAgentSkill(content, requiredSkill) {
     const nextSkills = `${skillsMatch[0].trimEnd()}\n  - ${requiredSkill}`;
     return content.replace(frontmatter, frontmatter.replace(skillsMatch[0], nextSkills));
 }
+function removeAgentSkill(content, removedSkill) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const frontmatter = frontmatterMatch[0];
+    const skillsMatch = frontmatter.match(/^skills:[ \t]*(?:\r?\n((?:\s+-\s+[^\r\n]+\r?\n?)*))?/m);
+    if (!skillsMatch) {
+        return content;
+    }
+    const listedSkills = (skillsMatch[1] ?? "")
+        .split(/\r?\n/)
+        .map((line) => line.match(/^\s+-\s+(.+)$/)?.[1]?.trim())
+        .filter((skill) => Boolean(skill));
+    const remainingSkills = listedSkills.filter((skill) => skill !== removedSkill);
+    if (remainingSkills.length === listedSkills.length) {
+        return content;
+    }
+    const lineEnding = skillsMatch[0].includes("\r\n") ? "\r\n" : "\n";
+    const replacement = remainingSkills.length > 0
+        ? `skills:${lineEnding}${remainingSkills.map((skill) => `  - ${skill}`).join(lineEnding)}${lineEnding}`
+        : "";
+    return content.replace(frontmatter, frontmatter.replace(skillsMatch[0], replacement));
+}
 function migrateLegacyHarnessFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {

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

@@ -2,6 +2,19 @@ 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`;
+const MEMORY_REVIEW_ROLE_DRAFT_PATTERN = new RegExp(`^${escapeRegExp(MEMORY_REVIEW_RUNS_ROOT)}/[A-Za-z0-9._-]+/drafts/([A-Za-z0-9._-]+)\\.md$`);
+export function memoryReviewRoleDraftPath(runId, role) {
+    return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/drafts/${role}.md`;
+}
+export function isMemoryProposalSubmissionPath(artifactPath, role) {
+    if (artifactPath === ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH) {
+        return role === "architect";
+    }
+    return MEMORY_REVIEW_ROLE_DRAFT_PATTERN.exec(artifactPath)?.[1] === role;
+}
 export function architectPlanningCandidateSnapshotPath(runId) {
     return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/sources/architect-planning.md`;
 }
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}