vibe-coding-master 0.7.28 → 0.7.30

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/api/task-routes.js

@@ -70,7 +70,8 @@ export function registerTaskRoutes(app, deps) {
                 messages,
                 orchestration,
                 roundState,
-                workflowState
+                workflowState,
+                architectRestart: deps.architectRestartService.getState(project.repoRoot, taskSlug)
             };
         }
         catch (error) {
@@ -84,7 +85,8 @@ export function registerTaskRoutes(app, deps) {
                         updatedAt: new Date().toISOString()
                     },
                     roundState: degradedRoundState(taskSlug),
-                    workflowState: degradedWorkflowState(taskSlug)
+                    workflowState: degradedWorkflowState(taskSlug),
+                    architectRestart: deps.architectRestartService.getState(repoRoot, taskSlug)
                 };
             }
             throw error;

package/dist/backend/server.js

@@ -130,7 +130,8 @@ export async function createServer(deps, options = {}) {
         messageService: deps.messageService,
         taskLaunchService: deps.taskLaunchService,
         roundService: deps.roundService,
-        taskWorkflowService: deps.taskWorkflowService
+        taskWorkflowService: deps.taskWorkflowService,
+        architectRestartService: deps.architectRestartService
     });
     registerSessionRoutes(app, {
         projectService: deps.projectService,
@@ -251,11 +252,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 +262,12 @@ export function createDefaultServerDeps(options = {}) {
             return true;
         }
     });
+    const harnessFeedbackService = createHarnessFeedbackService({
+        fs,
+        runtime,
+        sessionService,
+        autoMemoryService
+    });
     const commandDispatcher = createCommandDispatcher({
         runtime,
         sessionService,
@@ -280,7 +282,8 @@ export function createDefaultServerDeps(options = {}) {
     const architectRestartService = createArchitectRestartService({
         fs,
         taskService,
-        sessionService
+        sessionService,
+        appSettings
     });
     const messageService = createMessageService({
         fs,
@@ -388,6 +391,7 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         harnessService,
         autoMemoryService,
+        harnessFeedbackService,
         gatewayService,
         jobGuard: createJobGuardService(),
         translationWorkerService,

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

@@ -1,7 +1,9 @@
 import path from "node:path";
 import { resolveRepoPath } from "../adapters/filesystem.js";
-import { VcmError } from "../errors.js";
+import { toVcmError, 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;
@@ -24,26 +26,65 @@ export function createArchitectRestartService(deps) {
             const key = taskKey(repoRoot, taskSlug);
             const existing = pendingByTask.get(key);
             if (existing?.sessionId === session.id) {
-                existing.stopped = false;
-                existing.deliveredMessageId = undefined;
-                existing.acceptedMessageId = undefined;
-                existing.gateAccepted = false;
-                existing.executing = false;
-                return { taskSlug, sessionId: session.id, status: "scheduled" };
+                if (existing.status === "blocked") {
+                    existing.status = "pending";
+                    existing.blocker = undefined;
+                    await tryRestart(existing);
+                    return {
+                        taskSlug,
+                        sessionId: session.id,
+                        status: "scheduled",
+                        ...(existing.memoryCandidatePath
+                            ? { memoryCandidatePath: existing.memoryCandidatePath }
+                            : {})
+                    };
+                }
+                return {
+                    taskSlug,
+                    sessionId: session.id,
+                    status: "already_scheduled",
+                    ...(existing.memoryCandidatePath
+                        ? { memoryCandidatePath: existing.memoryCandidatePath }
+                        : {})
+                };
             }
+            const memoryCandidatePath = (await deps.appSettings.getPreferences()).autoMemoryEnabled
+                ? ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH
+                : undefined;
             pendingByTask.set(key, {
                 repoRoot,
                 taskSlug,
                 sessionId: session.id,
                 stopped: false,
                 gateAccepted: false,
-                executing: false
+                status: "pending",
+                memoryCandidatePath
             });
-            return { taskSlug, sessionId: session.id, status: "scheduled" };
+            return {
+                taskSlug,
+                sessionId: session.id,
+                status: "scheduled",
+                ...(memoryCandidatePath ? { memoryCandidatePath } : {})
+            };
+        },
+        getState(repoRoot, taskSlug) {
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending) {
+                return null;
+            }
+            return {
+                taskSlug: pending.taskSlug,
+                sessionId: pending.sessionId,
+                status: pending.status,
+                ...(pending.memoryCandidatePath
+                    ? { memoryCandidatePath: pending.memoryCandidatePath }
+                    : {}),
+                ...(pending.blocker ? { blocker: { ...pending.blocker } } : {})
+            };
         },
         async recordArchitectStop(repoRoot, taskSlug, sessionId) {
             const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending || pending.sessionId !== sessionId) {
+            if (!pending || pending.sessionId !== sessionId || pending.status === "blocked") {
                 return;
             }
             pending.stopped = true;
@@ -54,7 +95,7 @@ export function createArchitectRestartService(deps) {
                 return;
             }
             const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending) {
+            if (!pending || pending.status === "blocked") {
                 return;
             }
             pending.deliveredMessageId = message.id;
@@ -65,7 +106,7 @@ export function createArchitectRestartService(deps) {
                 return;
             }
             const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending) {
+            if (!pending || pending.status === "blocked") {
                 return;
             }
             pending.acceptedMessageId = message.id;
@@ -73,7 +114,7 @@ export function createArchitectRestartService(deps) {
         },
         async recordArchitectureGateDisposition(repoRoot, taskSlug, accepted) {
             const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
-            if (!pending) {
+            if (!pending || pending.status === "blocked") {
                 return;
             }
             pending.gateAccepted = accepted;
@@ -106,7 +147,7 @@ export function createArchitectRestartService(deps) {
         }
     }
     async function tryRestart(pending) {
-        if (pending.executing
+        if (pending.status !== "pending"
             || !pending.stopped
             || !pending.deliveredMessageId
             || pending.deliveredMessageId !== pending.acceptedMessageId
@@ -115,14 +156,29 @@ export function createArchitectRestartService(deps) {
         }
         const session = await deps.sessionService.getRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE);
         if (!session
-            || session.id !== pending.sessionId
-            || session.status !== "running"
-            || session.activityStatus !== "idle") {
+            || session.id !== pending.sessionId) {
+            blockPending(pending, new VcmError({
+                code: "ARCHITECT_RESTART_SESSION_UNAVAILABLE",
+                message: "Architect restart is blocked because the scheduled Architect session no longer exists.",
+                statusCode: 409
+            }));
+            return;
+        }
+        if (session.status !== "running") {
+            blockPending(pending, new VcmError({
+                code: "ARCHITECT_RESTART_SESSION_NOT_RUNNING",
+                message: "Architect restart is blocked because the scheduled Architect session is not running.",
+                statusCode: 409
+            }));
             return;
         }
-        pending.executing = true;
+        if (session.activityStatus !== "idle") {
+            return;
+        }
+        pending.status = "executing";
         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,
@@ -131,8 +187,32 @@ export function createArchitectRestartService(deps) {
             });
             pendingByTask.delete(taskKey(pending.repoRoot, pending.taskSlug));
         }
-        catch {
-            pending.executing = false;
+        catch (error) {
+            blockPending(pending, error);
+        }
+    }
+    function blockPending(pending, error) {
+        const normalized = toVcmError(error);
+        pending.status = "blocked";
+        pending.blocker = {
+            code: normalized.code,
+            message: normalized.message,
+            blockedAt: new Date().toISOString()
+        };
+    }
+    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}.`);
         }
     }
 }
@@ -149,3 +229,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,