vibe-coding-master 0.7.28 → 0.7.29

package/README.md

@@ -451,7 +451,7 @@ Use it to:
 - view and edit shared or role-specific VCM memory
 - review and revert memory changes recorded in the active task worktree
 - copy file paths for discussion
-- review task harness after post-task memory processing completes
+- review task harness and consolidate optional Auto Memory in one retrospective
 - inspect commit diffs for harness changes
 - merge task harness commits back to the connected repository branch when
   appropriate
@@ -467,7 +467,14 @@ files.
 Review Task Harness after Final Acceptance, Project Manager, Architect, Coder,
 Tester, and an enabled 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.
+applies the result as part of the same Task Harness Retrospective. Roles cannot
+edit active memory directly.
+
+When Auto Memory is enabled, the planning Architect writes a provisional memory
+candidate before its post-planning Session restart. VCM snapshots that candidate
+into the later memory-review run. The replacement Architect validates it against
+the completed implementation and tests, and Harness Engineer reviews it with all
+final role proposals before anything becomes active memory.
 
 Shared memory is stored in the root `CLAUDE.md` `<VCM-memory>` block. Role memory
 is stored in the matching `.claude/agents/*.md` block. VCM changes only block
@@ -481,21 +488,32 @@ Post-task processing is ordered by the backend:
 ```text
 Final Acceptance
   -> Review Task Harness
+  -> Snapshot Architect planning-session memory candidate, when present
   -> Workflow-role memory proposals, when Auto Memory is enabled
-  -> Harness Engineer memory review, when Auto Memory is enabled
   -> Task Harness Retrospective
+       -> Review pending Harness Feedback
+       -> Review Auto Memory proposals, when Auto Memory is enabled
+  -> Apply reviewed memory, when Auto Memory is enabled
 ```
 
 Memory proposal prompts sent to Project Manager, Architect, Coder, Tester, and
 an enabled Reviewer use their normal task sessions and participate in
-Round/Turn tracking. Harness Engineer review and retrospective work remain tool
-role activity and do not participate in Round completion.
+Round/Turn tracking. Each proposed add, update, or removal identifies its
+shared or current-role target and its supporting evidence. Adds and updates
+also state why the memory is necessary, the impact of omitting it, and whether
+the knowledge belongs in memory or a durable document. Harness Engineer first
+reviews every existing memory entry, recording its retention reason, removal
+impact, and durable-document disposition, then evaluates the proposals and
+records the resulting changes in the Retrospective report. VCM validates that
+report structure before applying the reviewed memory. Harness Engineer review
+and retrospective work remain tool role activity and do not participate in
+Round completion.
 
 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.
+review requests collect proposals before starting the retrospective. A failed
+proposal collection or combined retrospective memory review must be retried
+from Harness Studio.
 
 ## Closing a Task
 

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

@@ -174,7 +174,6 @@ export function registerHarnessRoutes(app, deps) {
         if (!memoryReadiness.ready) {
             return deps.harnessFeedbackService.getState(project.repoRoot, task.taskSlug);
         }
-        await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
         return deps.harnessFeedbackService.startTaskRetrospective(project.repoRoot, {
             taskSlug: task.taskSlug,
             taskRepoRoot: task.worktreePath,

package/dist/backend/server.js

@@ -251,11 +251,6 @@ export function createDefaultServerDeps(options = {}) {
         runFixedInstaller: createScriptFixedHarnessInstaller(path.join(appRoot, "scripts/install-vcm-harness.mjs")),
         vcmVersion
     });
-    const harnessFeedbackService = createHarnessFeedbackService({
-        fs,
-        runtime,
-        sessionService
-    });
     const autoMemoryService = createAutoMemoryService({
         fs,
         git,
@@ -266,6 +261,12 @@ export function createDefaultServerDeps(options = {}) {
             return true;
         }
     });
+    const harnessFeedbackService = createHarnessFeedbackService({
+        fs,
+        runtime,
+        sessionService,
+        autoMemoryService
+    });
     const commandDispatcher = createCommandDispatcher({
         runtime,
         sessionService,
@@ -280,7 +281,8 @@ export function createDefaultServerDeps(options = {}) {
     const architectRestartService = createArchitectRestartService({
         fs,
         taskService,
-        sessionService
+        sessionService,
+        appSettings
     });
     const messageService = createMessageService({
         fs,
@@ -388,6 +390,7 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         harnessService,
         autoMemoryService,
+        harnessFeedbackService,
         gatewayService,
         jobGuard: createJobGuardService(),
         translationWorkerService,

package/dist/backend/services/architect-restart-service.js

@@ -2,6 +2,8 @@ import path from "node:path";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
+import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH } from "./memory-review-paths.js";
+import { validateMemoryProposal } from "./memory-proposal-validation.js";
 const ARCHITECT_ROLE = "architect";
 const PM_ROLE = "project-manager";
 const COMPLETE_PLAN_PATTERN = /^Planning Result:\s*complete\s*$/im;
@@ -21,6 +23,17 @@ export function createArchitectRestartService(deps) {
         async schedule(repoRoot, taskSlug) {
             const session = await requireRunningArchitect(repoRoot, taskSlug);
             await requireCompletePlan(repoRoot, taskSlug);
+            const memoryCandidatePath = (await deps.appSettings.getPreferences()).autoMemoryEnabled
+                ? ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH
+                : undefined;
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            const candidatePath = resolveRepoPath(getTaskRuntimeRepoRoot(task), ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH);
+            if (deps.fs.removePath) {
+                await deps.fs.removePath(candidatePath, { force: true });
+            }
+            else if (await deps.fs.pathExists(candidatePath)) {
+                await deps.fs.writeText(candidatePath, "");
+            }
             const key = taskKey(repoRoot, taskSlug);
             const existing = pendingByTask.get(key);
             if (existing?.sessionId === session.id) {
@@ -29,7 +42,13 @@ export function createArchitectRestartService(deps) {
                 existing.acceptedMessageId = undefined;
                 existing.gateAccepted = false;
                 existing.executing = false;
-                return { taskSlug, sessionId: session.id, status: "scheduled" };
+                existing.memoryCandidatePath = memoryCandidatePath;
+                return {
+                    taskSlug,
+                    sessionId: session.id,
+                    status: "scheduled",
+                    ...(memoryCandidatePath ? { memoryCandidatePath } : {})
+                };
             }
             pendingByTask.set(key, {
                 repoRoot,
@@ -37,9 +56,15 @@ export function createArchitectRestartService(deps) {
                 sessionId: session.id,
                 stopped: false,
                 gateAccepted: false,
-                executing: false
+                executing: false,
+                memoryCandidatePath
             });
-            return { taskSlug, sessionId: session.id, status: "scheduled" };
+            return {
+                taskSlug,
+                sessionId: session.id,
+                status: "scheduled",
+                ...(memoryCandidatePath ? { memoryCandidatePath } : {})
+            };
         },
         async recordArchitectStop(repoRoot, taskSlug, sessionId) {
             const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
@@ -123,6 +148,7 @@ export function createArchitectRestartService(deps) {
         pending.executing = true;
         try {
             await requireCompletePlan(pending.repoRoot, pending.taskSlug);
+            await requirePlanningMemoryCandidate(pending);
             await deps.sessionService.restartRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE, {
                 permissionMode: session.permissionMode,
                 model: session.model,
@@ -135,6 +161,21 @@ export function createArchitectRestartService(deps) {
             pending.executing = false;
         }
     }
+    async function requirePlanningMemoryCandidate(pending) {
+        if (!pending.memoryCandidatePath) {
+            return;
+        }
+        const task = await deps.taskService.loadTask(pending.repoRoot, pending.taskSlug);
+        const candidatePath = resolveRepoPath(getTaskRuntimeRepoRoot(task), pending.memoryCandidatePath);
+        if (!(await deps.fs.pathExists(candidatePath))) {
+            throw invalidMemoryCandidateError("the assigned candidate file does not exist.");
+        }
+        const content = await deps.fs.readText(candidatePath);
+        const validationError = validateMemoryProposal(content);
+        if (validationError) {
+            throw invalidMemoryCandidateError(`the assigned candidate ${validationError}.`);
+        }
+    }
 }
 function isArchitectToPm(message) {
     return message.fromRole === ARCHITECT_ROLE && message.toRole === PM_ROLE;
@@ -149,3 +190,10 @@ function incompletePlanError(reason) {
         statusCode: 409
     });
 }
+function invalidMemoryCandidateError(reason) {
+    return new VcmError({
+        code: "ARCHITECT_MEMORY_CANDIDATE_INVALID",
+        message: `Architect restart is waiting for its planning-session memory candidate because ${reason}`,
+        statusCode: 409
+    });
+}

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

@@ -5,9 +5,9 @@ import { resolveRepoPath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { readVcmMemoryBlock, replaceVcmMemoryBlock } from "../templates/harness/memory-block.js";
-const MEMORY_REVIEW_ROOT = ".ai/vcm/memory-review";
-const MEMORY_REVIEW_RUNS_ROOT = `${MEMORY_REVIEW_ROOT}/runs`;
-const MEMORY_REVIEW_STATE_PATH = `${MEMORY_REVIEW_ROOT}/state.json`;
+import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH, architectPlanningCandidateSnapshotPath, MEMORY_REVIEW_RUNS_ROOT, MEMORY_REVIEW_STATE_PATH } from "./memory-review-paths.js";
+import { validateMemoryProposal } from "./memory-proposal-validation.js";
+import { validateMemoryReviewReport } from "./memory-review-validation.js";
 const MEMORY_FILE_DEFINITIONS = [
     { path: "CLAUDE.md", title: "Shared Memory" },
     { path: ".claude/agents/project-manager.md", title: "Project Manager Memory", role: "project-manager" },
@@ -132,7 +132,6 @@ export function createAutoMemoryService(deps) {
             return getState(input.baseRepoRoot, input.taskRepoRoot);
         }
         if (active?.status === "reviewing") {
-            await dispatchHarnessReview(input.baseRepoRoot, input.taskRepoRoot, active);
             return getState(input.baseRepoRoot, input.taskRepoRoot);
         }
         if (active || !input.roundReady || !input.requestTrigger) {
@@ -174,6 +173,7 @@ export function createAutoMemoryService(deps) {
         const before = await readMemorySet(input.taskRepoRoot);
         await writeRunMemorySet(input.taskRepoRoot, runId, "before", before);
         await writeRunMemorySet(input.taskRepoRoot, runId, "after", before);
+        await snapshotArchitectPlanningCandidate(input.taskRepoRoot, runId);
         await persistRun(input.taskRepoRoot, {
             version: 1,
             runId,
@@ -202,6 +202,13 @@ export function createAutoMemoryService(deps) {
         const active = await loadActiveState(input.taskRepoRoot);
         if (active) {
             const disposition = active.status;
+            if (disposition === "reviewing") {
+                return {
+                    ready: true,
+                    disposition,
+                    trigger: active.trigger
+                };
+            }
             return {
                 ready: false,
                 disposition,
@@ -218,9 +225,60 @@ export function createAutoMemoryService(deps) {
         return {
             ready: false,
             disposition: "pending",
-            reason: "Auto Memory must complete for this Final Acceptance before Task Harness Retrospective."
+            reason: "Auto Memory proposals must be collected before Task Harness Retrospective."
+        };
+    }
+    async function prepareTaskRetrospectiveReview(taskRepoRoot, retrospectiveReportPath) {
+        if (!(await deps.appSettings.getPreferences()).autoMemoryEnabled) {
+            return undefined;
+        }
+        const state = await loadActiveState(taskRepoRoot);
+        if (!state) {
+            return undefined;
+        }
+        if (state.status !== "reviewing") {
+            throw new VcmError({
+                code: "AUTO_MEMORY_NOT_READY",
+                message: "Auto Memory proposals are not ready for Task Harness Retrospective.",
+                statusCode: 409,
+                hint: "Wait for every workflow role to finish its memory proposal, then retry Task Harness Retrospective."
+            });
+        }
+        if (state.reviewPromptDispatchedAt) {
+            throw new VcmError({
+                code: "AUTO_MEMORY_REVIEW_RUNNING",
+                message: "Task Harness Retrospective is already reviewing Auto Memory.",
+                statusCode: 409
+            });
+        }
+        const timestamp = now();
+        state.reviewPromptDispatchedAt = timestamp;
+        state.retrospectiveReportPath = retrospectiveReportPath;
+        state.updatedAt = timestamp;
+        await persistActiveState(taskRepoRoot, state);
+        const runRoot = resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}`);
+        const planningCandidatePath = await findPlanningCandidateSnapshot(taskRepoRoot, state.runId);
+        return {
+            runId: state.runId,
+            roleDraftsPath: path.join(runRoot, "drafts"),
+            currentMemoryPath: path.join(runRoot, "before"),
+            reviewedMemoryPath: path.join(runRoot, "after"),
+            proposalRoles: state.drafts.map((draft) => draft.role),
+            ...(planningCandidatePath
+                ? { planningCandidatePath: resolveRepoPath(taskRepoRoot, planningCandidatePath) }
+                : {})
         };
     }
+    async function cancelTaskRetrospectiveReview(taskRepoRoot, runId) {
+        const state = await loadActiveState(taskRepoRoot);
+        if (!state || state.runId !== runId || state.status !== "reviewing") {
+            return;
+        }
+        delete state.reviewPromptDispatchedAt;
+        delete state.retrospectiveReportPath;
+        state.updatedAt = now();
+        await persistActiveState(taskRepoRoot, state);
+    }
     async function isRoleMemoryTurn(taskRepoRoot, role) {
         const state = await loadActiveState(taskRepoRoot);
         const draft = state?.status === "collecting" ? currentDraft(state) : undefined;
@@ -255,8 +313,9 @@ export function createAutoMemoryService(deps) {
             return true;
         }
         const content = (await deps.fs.readText(draftAbsolutePath)).trim();
-        if (!content || !/^Decision:\s*(update|no-change)\s*$/im.test(content)) {
-            await failReview(input.taskRepoRoot, state, `${input.role} memory draft is missing a valid Decision: update or Decision: no-change field.`);
+        const validationError = content ? validateMemoryProposal(content) : "is empty";
+        if (validationError) {
+            await failReview(input.taskRepoRoot, state, `${input.role} memory draft ${validationError}.`);
             return true;
         }
         draft.status = "completed";
@@ -270,7 +329,6 @@ export function createAutoMemoryService(deps) {
         state.status = "reviewing";
         await persistActiveState(input.taskRepoRoot, state);
         await updateRunStatus(input.taskRepoRoot, state.runId, "reviewing", state.updatedAt);
-        await dispatchHarnessReview(input.baseRepoRoot, input.taskRepoRoot, state);
         return true;
     }
     async function handleHarnessEngineerHook(input) {
@@ -292,10 +350,23 @@ export function createAutoMemoryService(deps) {
             return true;
         }
         if (input.eventName === "StopFailure") {
-            await failReview(input.taskRepoRoot, state, "Harness Engineer memory review turn failed.");
+            await failReview(input.taskRepoRoot, state, "Task Harness Retrospective memory review turn failed.");
             return true;
         }
         if (input.eventName === "Stop") {
+            if (!state.retrospectiveReportPath
+                || !(await deps.fs.pathExists(state.retrospectiveReportPath))
+                || !(await deps.fs.readText(state.retrospectiveReportPath)).trim()) {
+                await failReview(input.taskRepoRoot, state, "Task Harness Retrospective did not write the required retrospective report.");
+                return true;
+            }
+            const report = await deps.fs.readText(state.retrospectiveReportPath);
+            const currentMemorySnapshot = await readRunMemorySet(input.taskRepoRoot, state.runId, "before");
+            const reportError = validateMemoryReviewReport(report, state.drafts.map((draft) => draft.role), hasSubstantiveMemory(currentMemorySnapshot));
+            if (reportError) {
+                await failReview(input.taskRepoRoot, state, `Task Harness Retrospective memory review report ${reportError}.`);
+                return true;
+            }
             await applyReviewedMemory(input.taskRepoRoot, state);
             return true;
         }
@@ -419,42 +490,15 @@ export function createAutoMemoryService(deps) {
             draft.status = "dispatched";
             state.updatedAt = now();
             await persistActiveState(taskRepoRoot, state);
-            await submitTerminalInput(deps.runtime, session.id, buildRoleDraftPrompt(taskRepoRoot, state, draft));
+            const planningCandidatePath = draft.role === "architect"
+                ? await findPlanningCandidateSnapshot(taskRepoRoot, state.runId)
+                : undefined;
+            await submitTerminalInput(deps.runtime, session.id, buildRoleDraftPrompt(taskRepoRoot, state, draft, planningCandidatePath));
         }
         catch (error) {
             await failReview(taskRepoRoot, state, `Unable to start ${draft.role} memory draft: ${errorMessage(error)}`);
         }
     }
-    async function dispatchHarnessReview(baseRepoRoot, taskRepoRoot, state) {
-        if (state.status !== "reviewing" || state.reviewPromptDispatchedAt) {
-            return;
-        }
-        if (deps.isHarnessEngineerAvailable && !(await deps.isHarnessEngineerAvailable(baseRepoRoot))) {
-            return;
-        }
-        try {
-            const existing = await deps.sessionService.getRoleSession(baseRepoRoot, state.taskSlug, "harness-engineer");
-            if (existing?.activityStatus === "running") {
-                return;
-            }
-            const input = { cols: 120, rows: 32 };
-            const session = existing?.status === "running"
-                ? existing
-                : existing?.claudeSessionId
-                    ? await deps.sessionService.resumeRoleSession(baseRepoRoot, state.taskSlug, "harness-engineer", input)
-                    : await deps.sessionService.startRoleSession(baseRepoRoot, state.taskSlug, "harness-engineer", input);
-            if (session.status !== "running" || session.activityStatus === "running" || !deps.runtime.getSession(session.id)) {
-                return;
-            }
-            state.reviewPromptDispatchedAt = now();
-            state.updatedAt = state.reviewPromptDispatchedAt;
-            await persistActiveState(taskRepoRoot, state);
-            await submitTerminalInput(deps.runtime, session.id, buildHarnessReviewPrompt(taskRepoRoot, state));
-        }
-        catch (error) {
-            await failReview(taskRepoRoot, state, `Unable to start Harness Engineer memory review: ${errorMessage(error)}`);
-        }
-    }
     async function ensureWorkflowRoleSession(baseRepoRoot, taskSlug, role) {
         const existing = await deps.sessionService.getRoleSession(baseRepoRoot, taskSlug, role);
         if (existing?.status === "running" && deps.runtime.getSession(existing.id)) {
@@ -467,6 +511,20 @@ export function createAutoMemoryService(deps) {
         }
         return deps.sessionService.startRoleSession(baseRepoRoot, taskSlug, role, options);
     }
+    async function snapshotArchitectPlanningCandidate(taskRepoRoot, runId) {
+        const sourcePath = resolveRepoPath(taskRepoRoot, ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH);
+        if (!(await deps.fs.pathExists(sourcePath))) {
+            return;
+        }
+        const snapshotPath = resolveRepoPath(taskRepoRoot, architectPlanningCandidateSnapshotPath(runId));
+        await deps.fs.writeText(snapshotPath, ensureTrailingNewline(await deps.fs.readText(sourcePath)));
+    }
+    async function findPlanningCandidateSnapshot(taskRepoRoot, runId) {
+        const relativePath = architectPlanningCandidateSnapshotPath(runId);
+        return await deps.fs.pathExists(resolveRepoPath(taskRepoRoot, relativePath))
+            ? relativePath
+            : undefined;
+    }
     async function applyReviewedMemory(taskRepoRoot, state) {
         try {
             const before = await readRunMemorySet(taskRepoRoot, state.runId, "before");
@@ -675,6 +733,8 @@ export function createAutoMemoryService(deps) {
         updateFile,
         revertRun,
         retryFailedReview,
+        prepareTaskRetrospectiveReview,
+        cancelTaskRetrospectiveReview,
         isRoleMemoryTurn,
         handleRoleHook,
         handleHarnessEngineerHook,
@@ -710,39 +770,30 @@ function toActiveReview(state) {
         error: state.error
     };
 }
-function buildRoleDraftPrompt(taskRepoRoot, state, draft) {
+function buildRoleDraftPrompt(taskRepoRoot, state, draft, planningCandidatePath) {
     const roleDefinition = MEMORY_FILE_DEFINITIONS.find((definition) => "role" in definition && definition.role === draft.role);
     if (!roleDefinition) {
         throw new Error(`Missing memory definition for role: ${draft.role}`);
     }
-    return [
+    const prompt = [
         "[VCM Task Harness Review: Memory Proposal]",
         "",
         "Use the vcm-propose-memory skill to submit the assigned proposal.",
         `Task worktree: ${taskRepoRoot}`,
         `Current shared memory block: ${resolveRepoPath(taskRepoRoot, "CLAUDE.md")}`,
         `Current role memory block: ${resolveRepoPath(taskRepoRoot, roleDefinition.path)}`,
-        `Write the draft to: ${resolveRepoPath(taskRepoRoot, draft.path)}`,
-        "",
-        "End the turn after writing the draft."
-    ].join("\n");
-}
-function buildHarnessReviewPrompt(taskRepoRoot, state) {
-    const runRoot = resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}`);
+        ...(planningCandidatePath
+            ? [
+                `Planning-session memory candidate: ${resolveRepoPath(taskRepoRoot, planningCandidatePath)}`,
+                "Review that candidate against final task evidence. Carry forward only facts that remain verified after implementation and testing."
+            ]
+            : []),
+        `Write the draft to: ${resolveRepoPath(taskRepoRoot, draft.path)}`
+    ];
     return [
-        "[VCM Task Harness Review: Memory Review]",
-        "",
-        "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")}`,
+        ...prompt,
         "",
-        "Each snapshot file contains only the matching <VCM-memory> block content, not the full host file.",
-        "Keep only verified, durable, reusable project knowledge. Merge duplicates, remove stale entries, and keep role-specific knowledge in the matching role file.",
-        "Do not record task narrative, temporary state, unverified conclusions, or Harness rules.",
-        "Do not edit product code, active harness files, active memory blocks, 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."
+        "End the turn after writing the draft."
     ].join("\n");
 }
 function requireMemoryFileDefinition(filePath) {
@@ -792,6 +843,12 @@ function hashMemorySet(memory) {
         sha256(memory[definition.path] ?? "")
     ]));
 }
+function hasSubstantiveMemory(memory) {
+    return Object.values(memory).some((content) => {
+        const normalized = content.trim();
+        return Boolean(normalized && normalized !== "No accumulated project memory yet.");
+    });
+}
 function sameHashes(left, right) {
     return MEMORY_FILE_DEFINITIONS.every((definition) => left[definition.path] === right[definition.path]);
 }

package/dist/backend/services/claude-hook-service.js

@@ -133,7 +133,7 @@ export function createClaudeHookService(deps) {
         if (!session) {
             return completedHookResult(input, eventName);
         }
-        const activeTask = deps.autoMemoryService
+        const activeTask = deps.autoMemoryService || deps.harnessFeedbackService
             ? (await deps.taskService.listTasks(context.project.repoRoot))
                 .find((task) => task.cleanupStatus !== "cleaned" && (projectScoped || task.taskSlug === input.taskSlug))
             : undefined;
@@ -145,7 +145,17 @@ export function createClaudeHookService(deps) {
                 eventName
             })
             : false;
-        if (memoryHandled) {
+        const memoryState = activeTask && deps.autoMemoryService
+            ? await deps.autoMemoryService.getState(context.project.repoRoot, getTaskRuntimeRepoRoot(activeTask))
+            : undefined;
+        const retrospectiveHandled = activeTask
+            ? await deps.harnessFeedbackService?.handleTaskRetrospectiveHook(context.project.repoRoot, {
+                taskSlug: activeTask.taskSlug,
+                eventName,
+                memoryReviewSucceeded: memoryState?.status !== "failed"
+            })
+            : false;
+        if (memoryHandled || retrospectiveHandled) {
             return {
                 ok: true,
                 eventName,

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/harness/architect-agent.js

@@ -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/harness-engineer-agent.js

@@ -38,20 +38,23 @@ 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 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.
+  When the assigned prompt includes Auto Memory Review, also review the memory
+  proposals and write only the reviewed-memory 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.
 
 ## Change Policy
 
-- Apply edits only in Bootstrap Apply Mode, Memory Review Mode, or when VCM
-  explicitly asks you to apply an approved harness change.
+- Apply edits only in Bootstrap Apply Mode, to assigned reviewed-memory output
+  files during Retrospective Mode, or when VCM 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 and Retrospective Mode, do not edit files.
+- In Proposal Mode, do not edit files.
+- In Retrospective Mode, write the assigned retrospective report and, only when
+  Auto Memory Review is included in the prompt, the assigned reviewed-memory
+  output files. After every assigned pending feedback has a recorded
+  disposition, delete those processed feedback 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,11 +67,26 @@ You are not part of the task workflow round state.
 ## Memory Management
 
 - Own VCM-managed project memory in the root and role \`<VCM-memory>\` blocks.
-- 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 output.
+- When Auto Memory is disabled, do not request proposals or update memory.
+- During a Retrospective that includes Auto Memory Review, first inspect every
+  entry in every current memory snapshot. Verify each entry against current
+  code, durable documentation, and final task evidence. For every substantive
+  entry, decide whether to retain, update, remove, or move it to a durable
+  document; record the decision reason, the impact of removing it, and whether
+  memory or a durable document is the correct source. Complete this full review
+  even when every proposal says \`no-change\`.
+- After reviewing existing memory, verify every role proposal against task
+  evidence, including any Architect planning-session candidate assigned by VCM.
+  Independently verify the stated need, absence impact, and durable-document
+  disposition. Treat every candidate as a proposal rather than authority, merge
+  duplicates, remove stale entries, and keep role-specific knowledge in the
+  matching role memory output.
+- Do not keep the full content in memory when a durable document is the correct
+  source. Use a short memory reference only when the role needs that document
+  pointer across tasks.
+- Record every proposal disposition and the retained, updated, and removed
+  existing-memory decisions and summary in the exact Memory Review report block
+  assigned by VCM.
 - Do not record task narrative, temporary state, unverified conclusions, or
   Harness rules in memory.
 - Edit only the review output paths assigned by VCM. Do not edit active
@@ -91,6 +109,28 @@ context, validation reports, Gate Review reports, final acceptance artifacts,
 memory drafts, applied memory diffs, current memory, and user corrections during
 the task.
 
+Pending Harness Feedback is part of the retrospective, not a separate phase.
+At the start of the retrospective, read every feedback file assigned by VCM
+from \`.ai/vcm/harness-feedback/pending/\`.
+
+For each pending feedback:
+
+- verify it against the current harness, task evidence, and project behavior
+- decide whether it is confirmed, rejected, duplicate, or already covered
+- record the feedback path, decision, evidence, impact, and required action in
+  the retrospective report
+
+Process every assigned feedback before completing the retrospective. A
+feedback item is processed even when it is rejected or already covered.
+
+Write the complete retrospective report before deleting any feedback file.
+After the report contains a disposition for every assigned feedback, delete
+those feedback files from \`.ai/vcm/harness-feedback/pending/\`.
+
+Do not delete a feedback file unless its disposition is already recorded in
+the retrospective report. Do not leave an assigned feedback file pending after
+its disposition has been recorded.
+
 For each finding, decide whether it is:
 
 - a reusable harness problem that should be fixed
@@ -108,6 +148,7 @@ Do not edit harness files during retrospective analysis. Write a concise analysi
 - impact
 - recommended harness change, or reason no harness change is needed
 - affected roles, skills, tools, or docs
+- pending feedback path and disposition
 
 ## VCM Feedback
 

package/dist/backend/templates/harness/restart-architect-skill.js

@@ -9,7 +9,12 @@ Run:
 .ai/tools/request-architect-restart
 \`\`\`
 
-If VCM reports \`scheduled\`, write the completed Architect-to-PM route message and end the turn. VCM keeps the current Architect session through any architecture-plan Gate revision rounds and restarts it only after the route is accepted by PM and that Gate is approved or explicitly excepted.
+If VCM reports \`scheduled\` with a non-empty \`memoryCandidatePath\`, use
+\`vcm-propose-memory\` to write a planning-session memory candidate to that exact
+path before writing the completed route. This candidate is provisional input for
+the later Auto Memory review; it does not edit active memory.
+
+Then write the completed Architect-to-PM route message and end the turn. VCM keeps the current Architect session through any architecture-plan Gate revision rounds and restarts it only after the route is accepted by PM and that Gate is approved or explicitly excepted.
 
 Do not use this skill for incomplete planning, user clarification, Debug Mode, Architecture Diagnosis Mode, or docs sync.`;
 }
@@ -54,7 +59,12 @@ def main():
     try:
         with urllib.request.urlopen(request, timeout=5) as response:
             payload = json.loads(response.read().decode("utf-8"))
-        emit(payload.get("status", "scheduled"), taskSlug=task_slug, sessionId=payload.get("sessionId"))
+        emit(
+            payload.get("status", "scheduled"),
+            taskSlug=task_slug,
+            sessionId=payload.get("sessionId"),
+            memoryCandidatePath=payload.get("memoryCandidatePath"),
+        )
         return 0
     except urllib.error.HTTPError as error:
         try:

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

@@ -5,8 +5,8 @@ role turns. Update reviewed memory only through the output paths assigned by VCM
 or explicit user edits in Harness Studio. When Auto Memory is disabled, do not
 initiate memory proposals, reviews, or updates.`
         : `Treat the \`<VCM-memory>\` block in this role definition as read-only. Only
-when VCM explicitly requests a proposal during Task Harness Review, use
-\`vcm-propose-memory\` and write the exact assigned draft path.`;
+when VCM explicitly assigns a memory proposal or candidate path, use
+\`vcm-propose-memory\` and write that exact path.`;
     return `### Role Memory
 
 The \`<VCM-memory>\` block in this role definition is accumulated project context,

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

@@ -1,33 +1,81 @@
 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.
+    return `Use this skill only when VCM explicitly requests a memory proposal or
+planning-session memory candidate and provides an exact path.
 
 ## Rules
 
 - Treat every \`<VCM-memory>\` block 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.
+- Write only to the exact path assigned by VCM. It must be either a role draft
+  under \`.ai/vcm/memory-review/runs/<run-id>/drafts/\` or a planning candidate
+  under \`.ai/vcm/memory-review/candidates/\` in the active task worktree.
+- If VCM did not provide a path, do not create a proposal.
 - Propose only verified, durable, reusable project knowledge supported by task
   evidence.
+- Target shared project knowledge to \`shared\`. Target knowledge used only by
+  the current role to \`current-role\`.
+- For every add or update, explain why the memory is necessary, what future
+  impact its absence would have, and whether the knowledge belongs in memory,
+  a durable document, or a short memory reference to a durable document.
+  Use exactly \`memory\`, \`durable-doc\`, or \`memory-reference\`. Use
+  \`Durable doc path: none\` with \`memory\` and an actual path with either
+  durable-document disposition.
 - 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
 
+Use this exact format for \`Decision: no-change\`:
+
 \`\`\`markdown
 # Memory Proposal
-Decision: update | no-change
+Decision: no-change
 
 ## Add
+none
 
 ## Update
+none
 
 ## Remove
+none
+\`\`\`
+
+For \`Decision: update\`, use one or more numbered items and write every field
+on one line. Use \`none\` as the complete body of an operation section that has
+no item:
+
+\`\`\`markdown
+# Memory Proposal
+Decision: update
 
-## Evidence
+## Add
+### Item 1
+Target: shared
+Content: <new memory entry>
+Reason: <why this must remain available across tasks>
+Impact if absent: <specific future role or task failure>
+Durable doc disposition: memory
+Durable doc path: none
+Evidence: <task artifact, code, or durable documentation>
+
+## Update
+### Item 1
+Target: current-role
+Existing: <exact existing memory entry>
+Content: <replacement memory entry>
+Reason: <why the replacement must remain available across tasks>
+Impact if absent: <specific future role or task failure>
+Durable doc disposition: memory-reference
+Durable doc path: docs/ARCHITECTURE.md
+Evidence: <task artifact, code, or durable documentation>
+
+## Remove
+### Item 1
+Target: current-role
+Existing: <exact existing memory entry>
+Evidence: <task artifact, code, or durable documentation>
 \`\`\`
 
 Use \`Decision: no-change\` when the completed task produced no qualifying

package/package.json

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