vibe-coding-master 0.7.0 → 0.7.1

package/README.md

@@ -390,11 +390,11 @@ VCM runs it from the active task worktree.
 
 ### Auto Memory
 
-Enable `Auto memory` in the `VCM Harness` sidebar group to collect durable role
-knowledge after a complete task passes Final Acceptance. Project Manager,
-Architect, Coder, Tester, and an enabled Gate Reviewer submit memory drafts in
-sequence. Harness Engineer verifies and consolidates them before VCM applies
-the result.
+`Auto memory` is the switch for the entire automated memory workflow. During
+Review Task Harness after Final Acceptance, Project Manager, Architect, Coder,
+Tester, and an enabled Gate Reviewer submit proposals in sequence through
+`vcm-propose-memory`. Harness Engineer verifies and consolidates them before VCM
+applies the result. Roles cannot edit active memory directly.
 
 Canonical memory is stored under the base repository's `.ai/vcm/memory/`.
 Harness Studio shows current memory and task-local applied history. Memory is
@@ -405,14 +405,16 @@ Post-task processing is ordered by the backend:
 
 ```text
 Final Acceptance
-  -> Auto Memory, when enabled
+  -> Review Task Harness
+  -> Memory proposals and Harness Engineer review, when Auto Memory is enabled
   -> Task Harness Retrospective
 ```
 
-Auto Memory adds no retrospective prerequisite when it is disabled. When it is
-enabled, both automatic and manual retrospective requests wait until memory has
-been applied for the current Final Acceptance. A failed memory review must be
-retried from Harness Studio before retrospective can run.
+When Auto Memory is disabled, Review Task Harness does not collect proposals or
+ask Harness Engineer to update memory. When enabled, both automatic and manual
+review requests complete the memory phase before retrospective analysis. A
+failed memory review must be retried from Harness Studio before retrospective
+can continue.
 
 ## Closing a Task
 

package/dist/backend/api/harness-routes.js

@@ -154,15 +154,21 @@ export function registerHarnessRoutes(app, deps) {
     });
     app.post("/api/projects/harness/task-retrospective", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
-        await deps.autoMemoryService.assertTaskRetrospectiveReady({
+        const trigger = request.body?.trigger === "auto" ? "auto" : "manual";
+        const memoryInput = {
             baseRepoRoot: project.repoRoot,
             taskRepoRoot: task.worktreePath,
             taskSlug: task.taskSlug,
             handoffDir: task.handoffDir,
-            roundReady: true
-        });
+            roundReady: true,
+            requestTrigger: trigger
+        };
+        await deps.autoMemoryService.reconcileTask(memoryInput);
+        const memoryReadiness = await deps.autoMemoryService.getTaskRetrospectiveReadiness(memoryInput);
+        if (!memoryReadiness.ready) {
+            return deps.harnessFeedbackService.getState(project.repoRoot, task.taskSlug);
+        }
         await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
-        const trigger = request.body?.trigger === "auto" ? "auto" : "manual";
         return deps.harnessFeedbackService.startTaskRetrospective(project.repoRoot, {
             taskSlug: task.taskSlug,
             taskRepoRoot: task.worktreePath,

package/dist/backend/cli/install-vcm-harness.js

@@ -20,6 +20,7 @@ import { renderTesterHarnessRules } from "../templates/harness/tester-agent.js";
 import { renderVcmFinalAcceptanceSkillRules } from "../templates/harness/vcm-final-acceptance-skill.js";
 import { renderVcmHarnessBootstrapSkillRules } from "../templates/harness/vcm-harness-bootstrap-skill.js";
 import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/vcm-long-running-validation-skill.js";
+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 { readVcmPackageVersion } from "../app-version.js";
@@ -248,6 +249,12 @@ const WHOLE_FILES = [
         mode: 0o644,
         content: renderSkillFile("VCM Report Harness Issue Skill", "vcm-report-harness-issue", "Use when a VCM role notices a reusable harness problem and needs to record feedback for Harness Engineer review.", renderVcmReportHarnessIssueSkillRules())
     },
+    {
+        path: ".claude/skills/vcm-propose-memory/SKILL.md",
+        category: "skill",
+        mode: 0o644,
+        content: renderSkillFile("VCM Propose Memory Skill", "vcm-propose-memory", "Use only when VCM requests a role memory proposal during Task Harness Review.", renderVcmProposeMemorySkillRules())
+    },
     {
         path: ".ai/tools/request-gate-review",
         category: "runtime-tool",
@@ -476,6 +483,7 @@ function fixedDirectories() {
         ".claude/skills/vcm-route-message/",
         ".claude/skills/vcm-gate-review/",
         ".claude/skills/vcm-report-harness-issue/",
+        ".claude/skills/vcm-propose-memory/",
         ".ai/vcm/translations/",
         ".ai/vcm/gate-reviews/",
         ".ai/tools/",

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

@@ -62,11 +62,16 @@ export function createAutoMemoryService(deps) {
     }
     async function getState(baseRepoRoot, taskRepoRoot) {
         await ensureTaskMemorySnapshot(deps.fs, baseRepoRoot, taskRepoRoot);
-        const [active, runs, files] = await Promise.all([
+        let [active, runs, files] = await Promise.all([
             loadActiveState(taskRepoRoot),
             listRuns(taskRepoRoot),
             listMemoryFiles(taskRepoRoot)
         ]);
+        if (active && !(await deps.appSettings.getPreferences()).autoMemoryEnabled) {
+            await discardActiveReview(taskRepoRoot, active);
+            active = undefined;
+            runs = await listRuns(taskRepoRoot);
+        }
         return {
             version: 1,
             status: active?.status ?? "idle",
@@ -79,6 +84,13 @@ export function createAutoMemoryService(deps) {
     async function reconcileTask(input) {
         await ensureTaskMemorySnapshot(deps.fs, input.baseRepoRoot, input.taskRepoRoot);
         const active = await loadActiveState(input.taskRepoRoot);
+        const preferences = await deps.appSettings.getPreferences();
+        if (!preferences.autoMemoryEnabled) {
+            if (active) {
+                await discardActiveReview(input.taskRepoRoot, active);
+            }
+            return getState(input.baseRepoRoot, input.taskRepoRoot);
+        }
         if (active?.status === "collecting") {
             await dispatchCurrentDraft(input.baseRepoRoot, input.taskRepoRoot, active);
             return getState(input.baseRepoRoot, input.taskRepoRoot);
@@ -87,11 +99,7 @@ export function createAutoMemoryService(deps) {
             await dispatchHarnessReview(input.baseRepoRoot, input.taskRepoRoot, active);
             return getState(input.baseRepoRoot, input.taskRepoRoot);
         }
-        if (active || !input.roundReady) {
-            return getState(input.baseRepoRoot, input.taskRepoRoot);
-        }
-        const preferences = await deps.appSettings.getPreferences();
-        if (!preferences.autoMemoryEnabled) {
+        if (active || !input.roundReady || !input.requestTrigger) {
             return getState(input.baseRepoRoot, input.taskRepoRoot);
         }
         if (deps.isHarnessEngineerAvailable && !(await deps.isHarnessEngineerAvailable(input.baseRepoRoot))) {
@@ -122,6 +130,7 @@ export function createAutoMemoryService(deps) {
             taskSlug: input.taskSlug,
             status: "collecting",
             finalAcceptanceHash,
+            trigger: input.requestTrigger,
             createdAt: timestamp,
             updatedAt: timestamp,
             drafts
@@ -138,6 +147,7 @@ export function createAutoMemoryService(deps) {
             createdAt: timestamp,
             updatedAt: timestamp,
             finalAcceptanceHash,
+            trigger: input.requestTrigger,
             beforeHashes: hashMemorySet(before)
         });
         await persistActiveState(input.taskRepoRoot, state);
@@ -159,13 +169,15 @@ export function createAutoMemoryService(deps) {
             return {
                 ready: false,
                 disposition,
+                trigger: active.trigger,
                 reason: disposition === "failed"
                     ? "Auto Memory failed for this task. Retry it before Task Harness Retrospective."
                     : `Auto Memory is ${disposition} for this task.`
             };
         }
-        if (await hasCompletedRunForFinalAcceptance(input.taskRepoRoot, finalAcceptanceHash)) {
-            return { ready: true, disposition: "completed" };
+        const completedRun = await findCompletedRunForFinalAcceptance(input.taskRepoRoot, finalAcceptanceHash);
+        if (completedRun) {
+            return { ready: true, disposition: "completed", trigger: completedRun.trigger };
         }
         return {
             ready: false,
@@ -173,18 +185,6 @@ export function createAutoMemoryService(deps) {
             reason: "Auto Memory must complete for this Final Acceptance before Task Harness Retrospective."
         };
     }
-    async function assertTaskRetrospectiveReady(input) {
-        const readiness = await getTaskRetrospectiveReadiness(input);
-        if (readiness.ready) {
-            return;
-        }
-        throw new VcmError({
-            code: "TASK_MEMORY_REVIEW_NOT_READY",
-            message: "Task Harness Retrospective must run after Auto Memory.",
-            statusCode: 409,
-            hint: readiness.reason
-        });
-    }
     async function isRoleMemoryTurn(taskRepoRoot, role) {
         const state = await loadActiveState(taskRepoRoot);
         const draft = state?.status === "collecting" ? currentDraft(state) : undefined;
@@ -192,6 +192,13 @@ export function createAutoMemoryService(deps) {
     }
     async function handleRoleHook(input) {
         const state = await loadActiveState(input.taskRepoRoot);
+        if (!(await deps.appSettings.getPreferences()).autoMemoryEnabled) {
+            if (state) {
+                await discardActiveReview(input.taskRepoRoot, state);
+                return true;
+            }
+            return false;
+        }
         const draft = state?.status === "collecting" ? currentDraft(state) : undefined;
         if (!state || !draft || draft.role !== input.role) {
             return false;
@@ -237,13 +244,17 @@ export function createAutoMemoryService(deps) {
     }
     async function handleHarnessEngineerHook(input) {
         const state = await loadActiveState(input.taskRepoRoot);
+        if (!(await deps.appSettings.getPreferences()).autoMemoryEnabled) {
+            if (state) {
+                await discardActiveReview(input.taskRepoRoot, state);
+                return true;
+            }
+            return false;
+        }
         if (state?.status === "reviewing" && !state.reviewPromptDispatchedAt) {
             return false;
         }
         if (!state || state.status !== "reviewing") {
-            if (input.eventName === "Stop") {
-                await captureHarnessEngineerChanges(input.baseRepoRoot, input.taskRepoRoot, input.taskSlug);
-            }
             return false;
         }
         if (input.eventName === "UserPromptSubmit" || input.eventName === "PostCompact") {
@@ -329,6 +340,10 @@ export function createAutoMemoryService(deps) {
     }
     async function assertHarnessEngineerAvailable(taskRepoRoot) {
         const state = await loadActiveState(taskRepoRoot);
+        if (state && !(await deps.appSettings.getPreferences()).autoMemoryEnabled) {
+            await discardActiveReview(taskRepoRoot, state);
+            return;
+        }
         if (!state || state.status === "failed") {
             return;
         }
@@ -341,6 +356,10 @@ export function createAutoMemoryService(deps) {
     }
     async function assertNoActiveReview(taskRepoRoot) {
         const state = await loadActiveState(taskRepoRoot);
+        if (state && !(await deps.appSettings.getPreferences()).autoMemoryEnabled) {
+            await discardActiveReview(taskRepoRoot, state);
+            return;
+        }
         if (!state) {
             return;
         }
@@ -437,17 +456,6 @@ export function createAutoMemoryService(deps) {
             await failReview(taskRepoRoot, state, `Harness Engineer memory result could not be applied: ${errorMessage(error)}`);
         }
     }
-    async function captureHarnessEngineerChanges(baseRepoRoot, taskRepoRoot, taskSlug) {
-        await ensureTaskMemorySnapshot(deps.fs, baseRepoRoot, taskRepoRoot);
-        const [before, after] = await Promise.all([
-            readMemorySet(baseRepoRoot),
-            readMemorySet(taskRepoRoot)
-        ]);
-        if (sameHashes(hashMemorySet(before), hashMemorySet(after))) {
-            return;
-        }
-        await createAppliedRun(baseRepoRoot, taskRepoRoot, taskSlug, "harness-engineer", before, after);
-    }
     async function createAppliedRun(baseRepoRoot, taskRepoRoot, taskSlug, source, before, after) {
         assertCompleteMemorySet(after);
         const timestamp = now();
@@ -513,6 +521,7 @@ export function createAutoMemoryService(deps) {
                 failedAt: run.failedAt,
                 revertedAt: run.revertedAt,
                 finalAcceptanceHash: run.finalAcceptanceHash,
+                trigger: run.trigger,
                 diff: run.diff ?? "",
                 canRevert: run.status === "applied" && !run.revertedAt && Boolean(run.afterHashes),
                 error: run.error
@@ -534,8 +543,11 @@ export function createAutoMemoryService(deps) {
         return files;
     }
     async function hasCompletedRunForFinalAcceptance(taskRepoRoot, finalAcceptanceHash) {
+        return Boolean(await findCompletedRunForFinalAcceptance(taskRepoRoot, finalAcceptanceHash));
+    }
+    async function findCompletedRunForFinalAcceptance(taskRepoRoot, finalAcceptanceHash) {
         const runs = await listRuns(taskRepoRoot);
-        return runs.some((run) => run.finalAcceptanceHash === finalAcceptanceHash && (run.status === "applied" || run.status === "reverted"));
+        return runs.find((run) => run.finalAcceptanceHash === finalAcceptanceHash && (run.status === "applied" || run.status === "reverted"));
     }
     async function loadActiveState(taskRepoRoot) {
         const statePath = resolveRepoPath(taskRepoRoot, MEMORY_REVIEW_STATE_PATH);
@@ -551,6 +563,10 @@ export function createAutoMemoryService(deps) {
     async function clearActiveState(taskRepoRoot) {
         await deps.fs.removePath?.(resolveRepoPath(taskRepoRoot, MEMORY_REVIEW_STATE_PATH), { force: true });
     }
+    async function discardActiveReview(taskRepoRoot, state) {
+        await clearActiveState(taskRepoRoot);
+        await deps.fs.removePath?.(resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}`), { recursive: true, force: true });
+    }
     async function readRun(taskRepoRoot, runId) {
         const runPath = resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${requireSafeRunId(runId)}/run.json`);
         if (!(await deps.fs.pathExists(runPath))) {
@@ -590,7 +606,6 @@ export function createAutoMemoryService(deps) {
         reconcileTask,
         getState,
         getTaskRetrospectiveReadiness,
-        assertTaskRetrospectiveReady,
         getFile,
         updateFile,
         revertRun,
@@ -629,44 +644,36 @@ function toActiveReview(state) {
         updatedAt: state.updatedAt,
         currentRole: state.status === "collecting" ? currentDraft(state)?.role : undefined,
         drafts: state.drafts,
+        trigger: state.trigger,
         error: state.error
     };
 }
 function buildRoleDraftPrompt(taskRepoRoot, state, draft) {
     return [
-        "[VCM Auto Memory Draft]",
+        "[VCM Task Harness Review: Memory Proposal]",
         "",
-        "The task passed Final Acceptance. Propose only durable, reusable memory supported by this task's evidence.",
+        "Use the vcm-propose-memory skill to submit the assigned proposal.",
         `Task worktree: ${taskRepoRoot}`,
         `Current shared memory: ${resolveRepoPath(taskRepoRoot, `${MEMORY_ROOT}/shared.md`)}`,
         `Current role memory: ${resolveRepoPath(taskRepoRoot, `${MEMORY_ROOT}/roles/${draft.role}.md`)}`,
         `Write the draft to: ${resolveRepoPath(taskRepoRoot, draft.path)}`,
         "",
-        "Use this structure:",
-        "# Memory Draft",
-        "Decision: update | no-change",
-        "## Add",
-        "## Update",
-        "## Remove",
-        "## Evidence",
-        "",
-        "Do not edit memory files, route messages, or handoff artifacts. Do not record task narrative, temporary state, unverified conclusions, or rules that belong in the harness.",
         "End the turn after writing the draft."
     ].join("\n");
 }
 function buildHarnessReviewPrompt(taskRepoRoot, state) {
     const runRoot = resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}`);
     return [
-        "[VCM Auto Memory Review]",
+        "[VCM Task Harness Review: Memory Review]",
         "",
-        "Review the role drafts and task evidence, then produce the complete next memory set.",
+        "Auto Memory is enabled. Review the role proposals and task evidence, then produce the complete next memory set.",
         `Task worktree: ${taskRepoRoot}`,
         `Role drafts: ${path.join(runRoot, "drafts")}`,
         `Current memory snapshot: ${path.join(runRoot, "before")}`,
         `Write the complete reviewed memory set to: ${path.join(runRoot, "after")}`,
         "",
         "Keep only verified, durable, reusable project knowledge. Merge duplicates, remove stale entries, and keep role-specific knowledge in the matching role file.",
-        "Memory is context, not authority. Keep harness rules and task-specific narrative out of memory.",
+        "Do not record task narrative, temporary state, unverified conclusions, or Harness rules.",
         "Do not edit product code, harness files, the canonical base-repository memory, or review metadata.",
         "All existing files already exist in the after directory. Edit those files in place and end the turn when review is complete."
     ].join("\n");

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

@@ -17,6 +17,7 @@ import { renderTesterHarnessRules } from "../templates/harness/tester-agent.js";
 import { renderVcmFinalAcceptanceSkillRules } from "../templates/harness/vcm-final-acceptance-skill.js";
 import { renderVcmHarnessBootstrapSkillRules } from "../templates/harness/vcm-harness-bootstrap-skill.js";
 import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/vcm-long-running-validation-skill.js";
+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 { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -142,6 +143,14 @@ const HARNESS_FILES = [
         ownership: "whole-file",
         renderRules: renderVcmReportHarnessIssueSkillRules
     },
+    {
+        kind: "skill-vcm-propose-memory",
+        path: ".claude/skills/vcm-propose-memory/SKILL.md",
+        title: "VCM Propose Memory Skill",
+        frontmatter: renderSkillFrontmatter("vcm-propose-memory", "Use only when VCM requests a role memory proposal during Task Harness Review."),
+        ownership: "whole-file",
+        renderRules: renderVcmProposeMemorySkillRules
+    },
     {
         kind: "agent-gate-reviewer",
         path: ".claude/agents/gate-reviewer.md",

package/dist/backend/services/runtime-coordinator-service.js

@@ -77,12 +77,10 @@ export function createRuntimeCoordinatorService(deps) {
                 else {
                     await deps.translationService.stopTask(taskRepoRoot, activeTask.taskSlug).catch(() => undefined);
                 }
-                await reconcileAutoMemory(repoRoot, activeTask);
-                if (preferences.autoTaskHarnessReviewEnabled) {
-                    const memoryReadiness = await getTaskRetrospectiveMemoryReadiness(repoRoot, activeTask);
-                    if (memoryReadiness.ready) {
-                        await maybeStartTaskHarnessRetrospective(repoRoot, activeTask);
-                    }
+                await reconcileAutoMemory(repoRoot, activeTask, preferences.autoTaskHarnessReviewEnabled ? "auto" : undefined);
+                const memoryReadiness = await getTaskRetrospectiveMemoryReadiness(repoRoot, activeTask);
+                if ((preferences.autoTaskHarnessReviewEnabled || memoryReadiness.trigger) && memoryReadiness.ready) {
+                    await maybeStartTaskHarnessRetrospective(repoRoot, activeTask, memoryReadiness.trigger ?? "auto");
                 }
                 return { activeTask, gatewayStatus };
             });
@@ -169,7 +167,7 @@ export function createRuntimeCoordinatorService(deps) {
             throw error;
         }
     }
-    async function maybeStartTaskHarnessRetrospective(repoRoot, task) {
+    async function maybeStartTaskHarnessRetrospective(repoRoot, task, trigger) {
         const stateRoot = await deps.getStateRoot(repoRoot);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const roundState = await deps.roundService.getSessionRoundState({
@@ -188,7 +186,7 @@ export function createRuntimeCoordinatorService(deps) {
                 taskSlug: task.taskSlug,
                 taskRepoRoot,
                 handoffDir: task.handoffDir,
-                trigger: "auto"
+                trigger
             });
         }
         catch (error) {
@@ -198,7 +196,7 @@ export function createRuntimeCoordinatorService(deps) {
             throw error;
         }
     }
-    async function reconcileAutoMemory(repoRoot, task) {
+    async function reconcileAutoMemory(repoRoot, task, requestTrigger) {
         const stateRoot = await deps.getStateRoot(repoRoot);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const roundState = await deps.roundService.getSessionRoundState({
@@ -212,6 +210,7 @@ export function createRuntimeCoordinatorService(deps) {
             taskRepoRoot,
             taskSlug: task.taskSlug,
             handoffDir: task.handoffDir,
+            requestTrigger,
             roundReady: roundState.status === "stopped"
                 && Boolean(roundState.roundId)
                 && roundState.roleRecovery?.status !== "failed"

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

@@ -8,6 +8,7 @@ export function renderRootClaudeHarnessRules() {
 - \`vcm-route-message\` is the only channel for PM-hub dispatch and reporting among project-manager, architect, coder, and tester. Gate Review and tool-role work use their dedicated VCM skills and controllers. Follow the route skill's write-then-stop rule.
 - 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.
+- Treat \`.ai/vcm/memory/**\` as read-only. Use \`vcm-propose-memory\` only when VCM assigns a memory proposal during Task Harness Review.
 - 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.
 
 ## VCM Harness Scope

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

@@ -38,9 +38,10 @@ You are not part of the task workflow round state.
   permitted bootstrap edits directly in the active task worktree and commit them
   yourself.
 - Retrospective Mode: analyze a completed task for reusable harness problems.
-  Do not edit harness files; proven repeated findings may update VCM memory.
-- Memory Review Mode: review role memory drafts or proven retrospective memory
-  findings and write only the memory files assigned by VCM.
+  Do not edit harness or memory files.
+- Memory Review Mode: when Auto Memory is enabled and VCM starts the memory
+  phase of Task Harness Review, review role proposals and write only the review
+  output files assigned by VCM.
 - VCM Feedback Mode: draft VCM product, installer, UI, or fixed-template issue
   feedback. Do not submit without explicit in-session user authorization.
 
@@ -50,8 +51,7 @@ You are not part of the task workflow round state.
   explicitly asks you to apply an approved harness change.
 - When applying edits, work only in the active task worktree named by VCM. Do not
   edit the base repository root unless VCM explicitly says so.
-- In Proposal Mode, do not edit files. In Retrospective Mode, do not edit
-  harness files; only the memory exception above may write files.
+- In Proposal Mode and Retrospective Mode, do not edit files.
 - Commit every applied harness change yourself before ending your turn.
 - Do not overwrite VCM fixed managed blocks.
 - Keep project-specific customization outside VCM managed blocks.
@@ -64,18 +64,16 @@ You are not part of the task workflow round state.
 ## Memory Management
 
 - Own VCM-managed project memory under \`.ai/vcm/memory/**\`.
-- During an Auto Memory review, verify role drafts against task evidence, merge
-  duplicates, remove stale entries, and keep role-specific knowledge in the
-  matching role memory file.
-- Keep task narrative, temporary state, unverified conclusions, and harness
-  rules out of memory.
-- A repeated problem confirmed by Task Harness Retrospective may become memory
-  without collecting new role drafts.
-- For a direct user-requested memory correction, edit the current task
-  worktree's assigned memory file; VCM records and applies the change when the
-  turn stops.
-- When VCM assigns review output paths, edit only those paths. VCM applies the
-  reviewed memory and records the diff.
+- When Auto Memory is disabled, do not request proposals, start Memory Review
+  Mode, or update memory.
+- During VCM-assigned Memory Review, verify every role proposal against task
+  evidence, merge duplicates, remove stale entries, and keep role-specific
+  knowledge in the matching role memory file.
+- Do not record task narrative, temporary state, unverified conclusions, or
+  Harness rules in memory.
+- Edit only the review output paths assigned by VCM. Do not edit
+  \`.ai/vcm/memory/**\` directly. VCM applies the reviewed output and records the
+  diff.
 
 ## Task Harness Retrospective
 

package/dist/backend/templates/harness/role-memory.js

@@ -1,9 +1,19 @@
 export function renderRoleMemoryRules(role) {
+    const proposalRule = role === "harness-engineer"
+        ? `Treat \`.ai/vcm/memory/**\` as read-only during role turns. Update memory
+only through VCM-assigned Memory Review output paths or explicit user edits in
+Harness Studio. When Auto Memory is disabled, do not initiate memory proposals,
+reviews, or updates.`
+        : `Treat \`.ai/vcm/memory/**\` as read-only. Do not create, edit, or delete
+memory files. Only when VCM explicitly requests a proposal during Task Harness
+Review, use \`vcm-propose-memory\` and write the exact assigned draft path.`;
     return `### Role Memory
 
 Before handling work in a session, read \`.ai/vcm/memory/roles/${role}.md\`.
 Read it again after context compaction before continuing.
 
 Treat memory as accumulated project context, not authority. Verify it against
-current code, documentation, and task evidence.`;
+current code, documentation, and task evidence.
+
+${proposalRule}`;
 }

package/dist/backend/templates/harness/vcm-propose-memory-skill.js

@@ -0,0 +1,35 @@
+export function renderVcmProposeMemorySkillRules() {
+    return `Use this skill only when VCM explicitly requests a memory proposal during Task
+Harness Review and provides an exact draft path.
+
+## Rules
+
+- Treat \`.ai/vcm/memory/**\` as read-only. This skill creates a proposal; it
+  never edits active memory.
+- Write only to the exact draft path assigned by VCM. The path must be under
+  \`.ai/vcm/memory-review/runs/<run-id>/drafts/\` in the active task worktree.
+- If VCM did not provide a draft path, do not create a proposal.
+- Propose only verified, durable, reusable project knowledge supported by task
+  evidence.
+- Do not record task narrative, temporary state, unverified conclusions, or
+  Harness rules.
+- Do not edit handoff artifacts or route messages from this skill.
+
+## Draft Format
+
+\`\`\`markdown
+# Memory Proposal
+Decision: update | no-change
+
+## Add
+
+## Update
+
+## Remove
+
+## Evidence
+\`\`\`
+
+Use \`Decision: no-change\` when the completed task produced no qualifying
+memory. End the turn after writing the assigned draft.`;
+}

package/package.json

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