vibe-coding-master 0.7.27 → 0.7.29

package/README.md

@@ -148,12 +148,15 @@ the active task worktree:
 - `.claude/agents/**`
 - `.claude/skills/**`
 - `.claude/settings.json` hooks
-- `.ai/tools/**`
+- VCM protocol and runtime tools under `.ai/tools/**`
 - `.gitignore` entries for VCM runtime state and task worktrees
-- generated-context tooling
+- initial project-owned generated-context tooling
 - pull request template
 
 VCM preserves user-authored content outside VCM managed blocks.
+VCM seeds `.ai/tools/generate-module-index` and
+`.ai/tools/generate-public-surface` only when missing. After installation these
+generators belong to the project and later harness updates do not replace them.
 
 The fixed harness install is deterministic and creates a commit in the active
 task worktree. Bootstrap is AI-assisted and is run through the Harness Engineer
@@ -448,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
@@ -464,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
@@ -478,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/cli/install-vcm-harness.js

@@ -229,13 +229,7 @@ const DURABLE_DOC_TEMPLATES = [
         content: "# Testing\n"
     },
 ];
-const WHOLE_FILES = [
-    {
-        path: ".ai/tools/check-durable-docs",
-        category: "durable-docs-tool",
-        mode: 0o755,
-        templatePath: "scripts/harness-tools/check-durable-docs"
-    },
+const PROJECT_OWNED_FILES = [
     {
         path: ".ai/tools/generate-module-index",
         category: "generated-context-tool",
@@ -247,6 +241,14 @@ const WHOLE_FILES = [
         category: "generated-context-tool",
         mode: 0o755,
         templatePath: "scripts/harness-tools/generate-public-surface"
+    }
+];
+const WHOLE_FILES = [
+    {
+        path: ".ai/tools/check-durable-docs",
+        category: "durable-docs-tool",
+        mode: 0o755,
+        templatePath: "scripts/harness-tools/check-durable-docs"
     },
     {
         path: ".claude/skills/vcm-architecture-interview/SKILL.md",
@@ -397,6 +399,9 @@ async function main() {
     for (const file of WHOLE_FILES) {
         await installWholeFile({ projectRoot, file, dryRun, operations });
     }
+    for (const file of PROJECT_OWNED_FILES) {
+        await installProjectOwnedFile({ projectRoot, file, dryRun, operations });
+    }
     await removeLegacyFlatSkillFiles({ projectRoot, dryRun, operations });
     await removeLegacyCodexHarnessPaths({ projectRoot, dryRun, operations });
     await installManifest({
@@ -511,6 +516,14 @@ async function buildManifest(projectRoot) {
             ...fixedDirectories().map((directory) => manifestEntry(directory, "directory", directoryCategory(directory), "vcm-created")),
             manifestEntry("docs/GLOSSARY.md", "file", "project-glossary", "project-owned"),
             manifestEntry("docs/CODING_STANDARDS.md", "file", "project-coding-standards", "project-owned"),
+            ...PROJECT_OWNED_FILES.map((file) => ({
+                path: file.path,
+                entryType: "file",
+                category: file.category,
+                ownership: "project-owned",
+                source: "vcm-template",
+                lifecycle: "long-term"
+            })),
             ...WHOLE_FILES.map((file) => ({
                 path: file.path,
                 entryType: "file",
@@ -820,6 +833,23 @@ async function installWholeFile({ projectRoot, file, dryRun, operations }) {
         action: "write fixed VCM file"
     });
 }
+async function installProjectOwnedFile({ projectRoot, file, dryRun, operations }) {
+    const targetPath = resolveInside(projectRoot, file.path);
+    if (await pathExists(targetPath)) {
+        operations.push(skip(file.path, "exists; project-owned"));
+        return;
+    }
+    const content = await wholeFileContent(file);
+    await writeIfChanged({
+        targetPath,
+        relativePath: file.path,
+        content: ensureTrailingNewline(content),
+        mode: file.mode,
+        dryRun,
+        operations,
+        action: "seed project-owned VCM file"
+    });
+}
 async function removeLegacyFlatSkillFiles({ projectRoot, dryRun, operations }) {
     const wholeFilesByPath = new Map(WHOLE_FILES.map((file) => [file.path, file]));
     for (const legacy of LEGACY_FLAT_SKILL_FILES) {

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,