vibe-coding-master 0.6.23 → 0.7.1

package/README.md

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

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

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

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

@@ -1,4 +1,4 @@
-import { DISPATCHABLE_ROLES, VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
 import { isOpenFileLimitError, VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerTaskRoutes(app, deps) {
@@ -92,39 +92,9 @@ export function registerTaskRoutes(app, deps) {
     });
     app.post("/api/tasks/:taskSlug/cleanup", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
-        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
-        await stopRunningRoleSessions(deps, project.repoRoot, request.params.taskSlug);
-        await moveProjectToolSessionsToSafeCwd(deps, project.repoRoot);
-        await deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), request.params.taskSlug, { clearCache: true });
-        deps.roundService.stopTask(request.params.taskSlug);
-        return deps.taskService.cleanupTask(project.repoRoot, request.params.taskSlug, request.body ?? {});
+        return deps.taskCloseService.closeTask(project.repoRoot, request.params.taskSlug);
     });
 }
-async function stopRunningRoleSessions(deps, repoRoot, taskSlug) {
-    const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
-    for (const session of sessions) {
-        if (session.status === "running" && VCM_ROLE_NAMES.some((role) => role === session.role)) {
-            await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
-        }
-    }
-}
-async function moveProjectToolSessionsToSafeCwd(deps, repoRoot) {
-    await Promise.all([
-        ignoreMissingSession(deps.sessionService.moveProjectTranslatorSessionToSafeCwd(repoRoot)),
-        ignoreMissingSession(deps.sessionService.moveProjectHarnessEngineerSessionToSafeCwd(repoRoot))
-    ]);
-}
-async function ignoreMissingSession(operation) {
-    try {
-        await operation;
-    }
-    catch (error) {
-        if (error instanceof VcmError && error.code === "SESSION_MISSING") {
-            return;
-        }
-        throw error;
-    }
-}
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();
     if (!project) {

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

@@ -20,6 +20,7 @@ import { renderTesterHarnessRules } from "../templates/harness/tester-agent.js";
 import { renderVcmFinalAcceptanceSkillRules } from "../templates/harness/vcm-final-acceptance-skill.js";
 import { renderVcmHarnessBootstrapSkillRules } from "../templates/harness/vcm-harness-bootstrap-skill.js";
 import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/vcm-long-running-validation-skill.js";
+import { renderVcmProposeMemorySkillRules } from "../templates/harness/vcm-propose-memory-skill.js";
 import { renderVcmReportHarnessIssueSkillRules } from "../templates/harness/vcm-report-harness-issue-skill.js";
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-skill.js";
 import { readVcmPackageVersion } from "../app-version.js";
@@ -36,7 +37,7 @@ const LEGACY_CODEX_HARNESS_PATHS = [
     ".ai/tools/request-codex-review"
 ];
 const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
-const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
+const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1 --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_PERMISSION_REQUEST_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_BASH_GUARD_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ]; then exit 0; fi; guard=""; repo="$(git rev-parse --show-toplevel 2>/dev/null || true)"; if [ -n "$repo" ] && [ -f "$repo/.ai/tools/vcm-bash-guard" ]; then guard="$repo/.ai/tools/vcm-bash-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-bash-guard" ]; then guard="$dir/.ai/tools/vcm-bash-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard"; fi; fi; [ -n "$guard" ] || exit 0; python3 "$guard" || exit 0'`;
 const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
@@ -248,6 +249,12 @@ const WHOLE_FILES = [
         mode: 0o644,
         content: renderSkillFile("VCM Report Harness Issue Skill", "vcm-report-harness-issue", "Use when a VCM role notices a reusable harness problem and needs to record feedback for Harness Engineer review.", renderVcmReportHarnessIssueSkillRules())
     },
+    {
+        path: ".claude/skills/vcm-propose-memory/SKILL.md",
+        category: "skill",
+        mode: 0o644,
+        content: renderSkillFile("VCM Propose Memory Skill", "vcm-propose-memory", "Use only when VCM requests a role memory proposal during Task Harness Review.", renderVcmProposeMemorySkillRules())
+    },
     {
         path: ".ai/tools/request-gate-review",
         category: "runtime-tool",
@@ -476,6 +483,7 @@ function fixedDirectories() {
         ".claude/skills/vcm-route-message/",
         ".claude/skills/vcm-gate-review/",
         ".claude/skills/vcm-report-harness-issue/",
+        ".claude/skills/vcm-propose-memory/",
         ".ai/vcm/translations/",
         ".ai/vcm/gate-reviews/",
         ".ai/tools/",

package/dist/backend/gateway/gateway-service.js

@@ -1,4 +1,3 @@
-import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
@@ -605,15 +604,7 @@ export function createGatewayService(deps) {
                 hint: settings.currentTaskSlug ? `Use /close-task confirm ${settings.currentTaskSlug}` : undefined
             });
         }
-        const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
-        await stopRunningRoleSessions(project.repoRoot, taskSlug);
-        await moveProjectToolSessionsToSafeCwd(project.repoRoot);
-        await deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true });
-        deps.roundService.stopTask(taskSlug);
-        const result = await deps.taskService.cleanupTask(project.repoRoot, taskSlug, {
-            force: true,
-            forceDeleteBranch: true
-        });
+        const result = await deps.taskCloseService.closeTask(project.repoRoot, taskSlug);
         clearFailedTranslation(project.repoRoot, taskSlug);
         const latestPmReplies = { ...settings.latestPmReplies };
         delete latestPmReplies[latestPmReplyKey(project.repoRoot, taskSlug)];
@@ -629,8 +620,9 @@ export function createGatewayService(deps) {
         });
         const lines = [
             `Closed task: ${result.taskSlug}`,
-            result.removedWorktreePath ? `removed worktree: ${result.removedWorktreePath}` : "removed worktree: none",
-            result.deletedBranch ? `deleted branch: ${result.deletedBranch}` : "deleted branch: none",
+            `worktree removed: ${result.worktreeRemoved ? "yes" : "no"}`,
+            `branch deleted: ${result.branchDeleted ? "yes" : "no"}`,
+            `task state removed: ${result.stateRemoved ? "yes" : "no"}`,
             `removed state paths: ${result.removedStatePaths.length}`
         ];
         if (result.warnings?.length) {
@@ -638,31 +630,6 @@ export function createGatewayService(deps) {
         }
         return lines.join("\n");
     }
-    async function stopRunningRoleSessions(repoRoot, taskSlug) {
-        const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
-        for (const session of sessions) {
-            if (session.status === "running" && VCM_ROLE_NAMES.some((role) => role === session.role)) {
-                await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
-            }
-        }
-    }
-    async function moveProjectToolSessionsToSafeCwd(repoRoot) {
-        await Promise.all([
-            ignoreMissingSession(deps.sessionService.moveProjectTranslatorSessionToSafeCwd(repoRoot)),
-            ignoreMissingSession(deps.sessionService.moveProjectHarnessEngineerSessionToSafeCwd(repoRoot))
-        ]);
-    }
-    async function ignoreMissingSession(operation) {
-        try {
-            await operation;
-        }
-        catch (error) {
-            if (error instanceof VcmError && error.code === "SESSION_MISSING") {
-                return;
-            }
-            throw error;
-        }
-    }
     async function setGatewayTranslation(enabled) {
         const settings = await deps.settings.updateSettings({ translationEnabled: enabled });
         return `Gateway translation ${settings.translationEnabled ? "on" : "off"}.`;

package/dist/backend/server.js

@@ -35,9 +35,11 @@ import { createRuntimeCoordinatorService } from "./services/runtime-coordinator-
 import { createRuntimeRecoveryService } from "./services/runtime-recovery-service.js";
 import { createStatusService } from "./services/status-service.js";
 import { createTaskService } from "./services/task-service.js";
+import { createTaskCloseService } from "./services/task-close-service.js";
 import { createTaskLaunchService } from "./services/task-launch-service.js";
 import { createTerminalInterruptService } from "./services/terminal-interrupt-service.js";
 import { createTranslationService } from "./services/translation-service.js";
+import { createTurnReconcilerService } from "./services/turn-reconciler-service.js";
 import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
 import { registerArtifactRoutes } from "./api/artifact-routes.js";
@@ -112,11 +114,10 @@ export async function createServer(deps, options = {}) {
     registerTaskRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
-        sessionService: deps.sessionService,
+        taskCloseService: deps.taskCloseService,
         statusService: deps.statusService,
         messageService: deps.messageService,
         taskLaunchService: deps.taskLaunchService,
-        translationService: deps.translationService,
         roundService: deps.roundService
     });
     registerSessionRoutes(app, {
@@ -154,9 +155,11 @@ export async function createServer(deps, options = {}) {
     });
     app.addHook("onReady", async () => {
         await cleanupRecentTranslationRuntime(deps);
+        deps.runtimeCoordinator.start();
         await deps.gatewayService.start();
     });
     app.addHook("onClose", async () => {
+        deps.runtimeCoordinator.stop();
         await deps.gatewayService.stop();
     });
     if (options.staticDir) {
@@ -306,6 +309,12 @@ export function createDefaultServerDeps(options = {}) {
         fs,
         auditPath: gatewaySettings.getAuditPath()
     });
+    const taskCloseService = createTaskCloseService({
+        taskService,
+        sessionService,
+        translationService,
+        roundService
+    });
     const gatewayService = createGatewayService({
         fs,
         settings: gatewaySettings,
@@ -313,6 +322,7 @@ export function createDefaultServerDeps(options = {}) {
         channels: gatewayChannels,
         projectService,
         taskService,
+        taskCloseService,
         sessionService,
         taskLaunchService,
         translationService,
@@ -320,20 +330,6 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         appSettings
     });
-    const runtimeCoordinator = createRuntimeCoordinatorService({
-        appSettings,
-        taskService,
-        sessionService,
-        translationService,
-        harnessService,
-        harnessFeedbackService,
-        autoMemoryService,
-        roundService,
-        gatewayService,
-        async getStateRoot(repoRoot) {
-            return (await projectService.loadConfig(repoRoot)).stateRoot;
-        }
-    });
     const runtimeRecoveryService = createRuntimeRecoveryService({
         fs,
         runtime,
@@ -357,6 +353,28 @@ export function createDefaultServerDeps(options = {}) {
         jobGuard: createJobGuardService(),
         translationWorkerService
     });
+    const turnReconciler = createTurnReconcilerService({
+        sessionService,
+        roundService,
+        claudeHookService,
+        runtime
+    });
+    const runtimeCoordinator = createRuntimeCoordinatorService({
+        appSettings,
+        projectService,
+        taskService,
+        sessionService,
+        translationService,
+        harnessService,
+        harnessFeedbackService,
+        autoMemoryService,
+        roundService,
+        gatewayService,
+        turnReconciler,
+        async getStateRoot(repoRoot) {
+            return (await projectService.loadConfig(repoRoot)).stateRoot;
+        }
+    });
     const terminalInterruptService = createTerminalInterruptService({
         runtime,
         projectService,
@@ -374,6 +392,7 @@ export function createDefaultServerDeps(options = {}) {
         appSettings,
         projectService,
         taskService,
+        taskCloseService,
         sessionService,
         artifactService,
         harnessService,

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

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