vibe-coding-master 0.7.4 → 0.7.6

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

@@ -4,25 +4,30 @@ import { checkMarkdownArtifact, readArtifactSectionValue } from "../../shared/va
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
-const MEMORY_ROOT = ".ai/vcm/memory";
+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`;
 const MEMORY_FILE_DEFINITIONS = [
-    { path: `${MEMORY_ROOT}/shared.md`, title: "Shared Memory" },
-    { path: `${MEMORY_ROOT}/roles/project-manager.md`, title: "Project Manager Memory", role: "project-manager" },
-    { path: `${MEMORY_ROOT}/roles/architect.md`, title: "Architect Memory", role: "architect" },
-    { path: `${MEMORY_ROOT}/roles/coder.md`, title: "Coder Memory", role: "coder" },
-    { path: `${MEMORY_ROOT}/roles/tester.md`, title: "Tester Memory", role: "tester" },
-    { path: `${MEMORY_ROOT}/roles/gate-reviewer.md`, title: "Gate Reviewer Memory", role: "gate-reviewer" },
-    { path: `${MEMORY_ROOT}/roles/harness-engineer.md`, title: "Harness Engineer Memory", role: "harness-engineer" }
+    { path: "CLAUDE.md", title: "Shared Memory" },
+    { path: ".claude/agents/project-manager.md", title: "Project Manager Memory", role: "project-manager" },
+    { path: ".claude/agents/architect.md", title: "Architect Memory", role: "architect" },
+    { path: ".claude/agents/coder.md", title: "Coder Memory", role: "coder" },
+    { path: ".claude/agents/tester.md", title: "Tester Memory", role: "tester" },
+    { path: ".claude/agents/gate-reviewer.md", title: "Gate Reviewer Memory", role: "gate-reviewer" },
+    { path: ".claude/agents/harness-engineer.md", title: "Harness Engineer Memory", role: "harness-engineer" }
 ];
 export function createAutoMemoryService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     async function readMemorySet(repoRoot) {
         const memory = {};
         for (const definition of MEMORY_FILE_DEFINITIONS) {
-            memory[definition.path] = await deps.fs.readText(resolveRepoPath(repoRoot, definition.path));
+            const hostContent = await deps.fs.readText(resolveRepoPath(repoRoot, definition.path));
+            const blockContent = readVcmMemoryBlock(hostContent);
+            if (blockContent === undefined) {
+                throw missingMemoryBlockError(definition.path);
+            }
+            memory[definition.path] = blockContent;
         }
         return memory;
     }
@@ -30,7 +35,8 @@ export function createAutoMemoryService(deps) {
         assertCompleteMemorySet(memory);
         for (const definition of MEMORY_FILE_DEFINITIONS) {
             const targetPath = resolveRepoPath(repoRoot, definition.path);
-            const content = ensureTrailingNewline(memory[definition.path]);
+            const hostContent = await deps.fs.readText(targetPath);
+            const content = replaceVcmMemoryBlock(hostContent, memory[definition.path]);
             if (deps.fs.writeTextAtomic) {
                 await deps.fs.writeTextAtomic(targetPath, content);
             }
@@ -39,9 +45,40 @@ export function createAutoMemoryService(deps) {
             }
         }
     }
-    async function applyMemorySet(baseRepoRoot, taskRepoRoot, memory) {
-        await writeMemorySet(baseRepoRoot, memory);
-        await writeMemorySet(taskRepoRoot, memory);
+    async function applyAndCommitMemorySet(taskRepoRoot, before, after, commitMessage) {
+        assertCompleteMemorySet(after);
+        const changedPaths = MEMORY_FILE_DEFINITIONS
+            .filter((definition) => before[definition.path] !== after[definition.path])
+            .map((definition) => definition.path);
+        if (changedPaths.length === 0) {
+            return;
+        }
+        const current = await readMemorySet(taskRepoRoot);
+        if (!sameHashes(hashMemorySet(current), hashMemorySet(before))) {
+            throw new VcmError({
+                code: "MEMORY_TARGET_CHANGED",
+                message: "VCM memory changed while the review was in progress.",
+                statusCode: 409,
+                hint: "Review the current memory, then retry the memory review."
+            });
+        }
+        const existingDiff = await deps.git.getDiff(taskRepoRoot, "HEAD", null, changedPaths);
+        if (existingDiff.trim()) {
+            throw new VcmError({
+                code: "MEMORY_HOST_FILE_DIRTY",
+                message: "A file containing VCM memory already has uncommitted changes.",
+                statusCode: 409,
+                hint: "Commit or discard the existing host-file changes before applying memory."
+            });
+        }
+        await writeMemorySet(taskRepoRoot, after);
+        try {
+            await deps.git.commitPaths(taskRepoRoot, commitMessage, changedPaths);
+        }
+        catch (error) {
+            await writeMemorySet(taskRepoRoot, before);
+            throw error;
+        }
     }
     async function writeRunMemorySet(taskRepoRoot, runId, snapshot, memory) {
         assertCompleteMemorySet(memory);
@@ -61,8 +98,7 @@ export function createAutoMemoryService(deps) {
         return memory;
     }
     async function getState(baseRepoRoot, taskRepoRoot) {
-        await ensureTaskMemorySnapshot(deps.fs, baseRepoRoot, taskRepoRoot);
-        let [active, runs, files] = await Promise.all([
+        let [active, runs, memoryFiles] = await Promise.all([
             loadActiveState(taskRepoRoot),
             listRuns(taskRepoRoot),
             listMemoryFiles(taskRepoRoot)
@@ -75,14 +111,13 @@ export function createAutoMemoryService(deps) {
         return {
             version: 1,
             status: active?.status ?? "idle",
-            files,
+            files: memoryFiles.files,
             runs,
             ...(active ? { active: toActiveReview(active) } : {}),
-            warnings: []
+            warnings: memoryFiles.warnings
         };
     }
     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) {
@@ -91,6 +126,7 @@ export function createAutoMemoryService(deps) {
             }
             return getState(input.baseRepoRoot, input.taskRepoRoot);
         }
+        await assertMemoryBlocksInstalled(deps.fs, input.taskRepoRoot);
         if (active?.status === "collecting") {
             await dispatchCurrentDraft(input.baseRepoRoot, input.taskRepoRoot, active);
             return getState(input.baseRepoRoot, input.taskRepoRoot);
@@ -135,7 +171,7 @@ export function createAutoMemoryService(deps) {
             updatedAt: timestamp,
             drafts
         };
-        const before = await readMemorySet(input.baseRepoRoot);
+        const before = await readMemorySet(input.taskRepoRoot);
         await writeRunMemorySet(input.taskRepoRoot, runId, "before", before);
         await writeRunMemorySet(input.taskRepoRoot, runId, "after", before);
         await persistRun(input.taskRepoRoot, {
@@ -188,7 +224,7 @@ export function createAutoMemoryService(deps) {
     async function isRoleMemoryTurn(taskRepoRoot, role) {
         const state = await loadActiveState(taskRepoRoot);
         const draft = state?.status === "collecting" ? currentDraft(state) : undefined;
-        return draft?.role === role && draft.status === "running";
+        return draft?.role === role && draft.status === "dispatched";
     }
     async function handleRoleHook(input) {
         const state = await loadActiveState(input.taskRepoRoot);
@@ -204,11 +240,6 @@ export function createAutoMemoryService(deps) {
             return false;
         }
         if (input.eventName === "UserPromptSubmit" || input.eventName === "PostCompact") {
-            if (draft.status !== "running") {
-                draft.status = "running";
-                state.updatedAt = now();
-                await persistActiveState(input.taskRepoRoot, state);
-            }
             return true;
         }
         if (input.eventName === "StopFailure") {
@@ -265,15 +296,19 @@ export function createAutoMemoryService(deps) {
             return true;
         }
         if (input.eventName === "Stop") {
-            await applyReviewedMemory(input.baseRepoRoot, input.taskRepoRoot, state);
+            await applyReviewedMemory(input.taskRepoRoot, state);
             return true;
         }
         return true;
     }
-    async function getFile(baseRepoRoot, taskRepoRoot, filePath) {
-        await ensureTaskMemorySnapshot(deps.fs, baseRepoRoot, taskRepoRoot);
+    async function getFile(_baseRepoRoot, taskRepoRoot, filePath) {
+        await assertMemoryBlocksInstalled(deps.fs, taskRepoRoot);
         const definition = requireMemoryFileDefinition(filePath);
-        const content = await deps.fs.readText(resolveRepoPath(taskRepoRoot, definition.path));
+        const hostContent = await deps.fs.readText(resolveRepoPath(taskRepoRoot, definition.path));
+        const content = readVcmMemoryBlock(hostContent);
+        if (content === undefined) {
+            throw missingMemoryBlockError(definition.path);
+        }
         return {
             path: definition.path,
             title: definition.title,
@@ -286,13 +321,13 @@ export function createAutoMemoryService(deps) {
     async function updateFile(baseRepoRoot, taskRepoRoot, taskSlug, filePath, content) {
         await assertNoActiveReview(taskRepoRoot);
         const definition = requireMemoryFileDefinition(filePath);
-        const before = await readMemorySet(baseRepoRoot);
+        const before = await readMemorySet(taskRepoRoot);
         const normalizedContent = ensureTrailingNewline(content);
         if (before[definition.path] === normalizedContent) {
             return getState(baseRepoRoot, taskRepoRoot);
         }
         const after = { ...before, [definition.path]: normalizedContent };
-        await createAppliedRun(baseRepoRoot, taskRepoRoot, taskSlug, "user", before, after);
+        await createAppliedRun(taskRepoRoot, taskSlug, "user", before, after);
         return getState(baseRepoRoot, taskRepoRoot);
     }
     async function revertRun(baseRepoRoot, taskRepoRoot, runId) {
@@ -305,7 +340,7 @@ export function createAutoMemoryService(deps) {
                 statusCode: 409
             });
         }
-        const current = await readMemorySet(baseRepoRoot);
+        const current = await readMemorySet(taskRepoRoot);
         if (!sameHashes(hashMemorySet(current), run.afterHashes)) {
             throw new VcmError({
                 code: "MEMORY_RUN_CHANGED",
@@ -315,8 +350,7 @@ export function createAutoMemoryService(deps) {
             });
         }
         const before = await readRunMemorySet(taskRepoRoot, run.runId, "before");
-        await writeMemorySet(baseRepoRoot, before);
-        await writeMemorySet(taskRepoRoot, before);
+        await applyAndCommitMemorySet(taskRepoRoot, current, before, "chore: revert VCM memory");
         const timestamp = now();
         await persistRun(taskRepoRoot, {
             ...run,
@@ -382,7 +416,7 @@ export function createAutoMemoryService(deps) {
             if (session.activityStatus === "running") {
                 return;
             }
-            draft.status = "running";
+            draft.status = "dispatched";
             state.updatedAt = now();
             await persistActiveState(taskRepoRoot, state);
             await submitTerminalInput(deps.runtime, session.id, buildRoleDraftPrompt(taskRepoRoot, state, draft));
@@ -399,15 +433,16 @@ export function createAutoMemoryService(deps) {
             return;
         }
         try {
-            const existing = await deps.sessionService.getProjectHarnessEngineerSession(baseRepoRoot);
+            const existing = await deps.sessionService.getRoleSession(baseRepoRoot, state.taskSlug, "harness-engineer");
             if (existing?.activityStatus === "running") {
                 return;
             }
-            const session = await deps.sessionService.ensureProjectHarnessEngineerSession(baseRepoRoot, {
-                taskSlug: state.taskSlug,
-                cols: 120,
-                rows: 32
-            });
+            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;
             }
@@ -432,12 +467,12 @@ export function createAutoMemoryService(deps) {
         }
         return deps.sessionService.startRoleSession(baseRepoRoot, taskSlug, role, options);
     }
-    async function applyReviewedMemory(baseRepoRoot, taskRepoRoot, state) {
+    async function applyReviewedMemory(taskRepoRoot, state) {
         try {
             const before = await readRunMemorySet(taskRepoRoot, state.runId, "before");
             const after = await readRunMemorySet(taskRepoRoot, state.runId, "after");
             assertCompleteMemorySet(after);
-            await applyMemorySet(baseRepoRoot, taskRepoRoot, after);
+            await applyAndCommitMemorySet(taskRepoRoot, before, after, "chore: update VCM memory");
             const timestamp = now();
             const diff = renderMemoryDiff(before, after);
             const run = await readRun(taskRepoRoot, state.runId);
@@ -456,28 +491,34 @@ export function createAutoMemoryService(deps) {
             await failReview(taskRepoRoot, state, `Harness Engineer memory result could not be applied: ${errorMessage(error)}`);
         }
     }
-    async function createAppliedRun(baseRepoRoot, taskRepoRoot, taskSlug, source, before, after) {
+    async function createAppliedRun(taskRepoRoot, taskSlug, source, before, after) {
         assertCompleteMemorySet(after);
         const timestamp = now();
         const runId = createRunId(timestamp, source);
         await writeRunMemorySet(taskRepoRoot, runId, "before", before);
         await writeRunMemorySet(taskRepoRoot, runId, "after", after);
-        await applyMemorySet(baseRepoRoot, taskRepoRoot, after);
-        const diff = renderMemoryDiff(before, after);
-        await persistRun(taskRepoRoot, {
-            version: 1,
-            runId,
-            taskSlug,
-            source,
-            status: "applied",
-            createdAt: timestamp,
-            updatedAt: timestamp,
-            appliedAt: timestamp,
-            beforeHashes: hashMemorySet(before),
-            afterHashes: hashMemorySet(after),
-            diff
-        });
-        await deps.fs.writeText(resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/applied.patch`), diff);
+        try {
+            await applyAndCommitMemorySet(taskRepoRoot, before, after, "chore: update VCM memory");
+            const diff = renderMemoryDiff(before, after);
+            await persistRun(taskRepoRoot, {
+                version: 1,
+                runId,
+                taskSlug,
+                source,
+                status: "applied",
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                appliedAt: timestamp,
+                beforeHashes: hashMemorySet(before),
+                afterHashes: hashMemorySet(after),
+                diff
+            });
+            await deps.fs.writeText(resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/applied.patch`), diff);
+        }
+        catch (error) {
+            await deps.fs.removePath?.(resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${runId}`), { recursive: true, force: true });
+            throw error;
+        }
     }
     async function failReview(taskRepoRoot, state, message) {
         const timestamp = now();
@@ -531,8 +572,21 @@ export function createAutoMemoryService(deps) {
     }
     async function listMemoryFiles(taskRepoRoot) {
         const files = [];
+        const warnings = [];
         for (const definition of MEMORY_FILE_DEFINITIONS) {
-            const content = await deps.fs.readText(resolveRepoPath(taskRepoRoot, definition.path));
+            let content = "";
+            const hostPath = resolveRepoPath(taskRepoRoot, definition.path);
+            try {
+                if (await deps.fs.pathExists(hostPath)) {
+                    content = readVcmMemoryBlock(await deps.fs.readText(hostPath)) ?? "";
+                }
+            }
+            catch (error) {
+                warnings.push(`${definition.path}: ${errorMessage(error)}`);
+            }
+            if (!content) {
+                warnings.push(`${definition.path}: VCM memory block is missing. Refresh the VCM Harness.`);
+            }
             files.push({
                 path: definition.path,
                 title: definition.title,
@@ -540,7 +594,7 @@ export function createAutoMemoryService(deps) {
                 sizeBytes: Buffer.byteLength(content, "utf8")
             });
         }
-        return files;
+        return { files, warnings: [...new Set(warnings)] };
     }
     async function hasCompletedRunForFinalAcceptance(taskRepoRoot, finalAcceptanceHash) {
         return Boolean(await findCompletedRunForFinalAcceptance(taskRepoRoot, finalAcceptanceHash));
@@ -554,8 +608,22 @@ export function createAutoMemoryService(deps) {
         if (!(await deps.fs.pathExists(statePath))) {
             return undefined;
         }
-        const state = await deps.fs.readJson(statePath);
-        return state?.version === 1 && state.runId ? state : undefined;
+        const stored = await deps.fs.readJson(statePath);
+        if (stored?.version !== 1 || !stored.runId) {
+            return undefined;
+        }
+        const migrated = stored.drafts.some((draft) => draft.status === "running");
+        const state = {
+            ...stored,
+            drafts: stored.drafts.map((draft) => ({
+                ...draft,
+                status: draft.status === "running" ? "dispatched" : draft.status
+            }))
+        };
+        if (migrated) {
+            await persistActiveState(taskRepoRoot, state);
+        }
+        return state;
     }
     async function persistActiveState(taskRepoRoot, state) {
         await deps.fs.writeJsonAtomic(resolveRepoPath(taskRepoRoot, MEMORY_REVIEW_STATE_PATH), state);
@@ -600,9 +668,6 @@ export function createAutoMemoryService(deps) {
         return `sha256:${sha256(content)}`;
     }
     return {
-        ensureTaskSnapshot(baseRepoRoot, taskRepoRoot) {
-            return ensureTaskMemorySnapshot(deps.fs, baseRepoRoot, taskRepoRoot);
-        },
         reconcileTask,
         getState,
         getTaskRetrospectiveReadiness,
@@ -616,21 +681,18 @@ export function createAutoMemoryService(deps) {
         assertHarnessEngineerAvailable
     };
 }
-export async function ensureTaskMemorySnapshot(fs, baseRepoRoot, taskRepoRoot) {
+export async function assertMemoryBlocksInstalled(fs, taskRepoRoot) {
     for (const definition of MEMORY_FILE_DEFINITIONS) {
-        const canonicalPath = resolveRepoPath(baseRepoRoot, definition.path);
-        if (!(await fs.pathExists(canonicalPath))) {
-            await fs.writeText(canonicalPath, renderDefaultMemoryFile(definition.title));
+        const hostPath = resolveRepoPath(taskRepoRoot, definition.path);
+        if (!(await fs.pathExists(hostPath))) {
+            throw missingMemoryBlockError(definition.path);
         }
-        const snapshotPath = resolveRepoPath(taskRepoRoot, definition.path);
-        if (!(await fs.pathExists(snapshotPath))) {
-            await fs.writeText(snapshotPath, await fs.readText(canonicalPath));
+        const content = await fs.readText(hostPath);
+        if (readVcmMemoryBlock(content) === undefined) {
+            throw missingMemoryBlockError(definition.path);
         }
     }
 }
-function renderDefaultMemoryFile(title) {
-    return `# ${title}\n\nNo accumulated project memory yet.\n`;
-}
 function currentDraft(state) {
     return state.drafts.find((draft) => draft.status !== "completed");
 }
@@ -649,13 +711,17 @@ function toActiveReview(state) {
     };
 }
 function buildRoleDraftPrompt(taskRepoRoot, state, draft) {
+    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 [
         "[VCM Task Harness Review: Memory Proposal]",
         "",
         "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`)}`,
+        `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."
@@ -672,9 +738,10 @@ function buildHarnessReviewPrompt(taskRepoRoot, state) {
         `Current memory snapshot: ${path.join(runRoot, "before")}`,
         `Write the complete reviewed memory set to: ${path.join(runRoot, "after")}`,
         "",
+        "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, harness files, the canonical base-repository memory, or review metadata.",
+        "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."
     ].join("\n");
 }
@@ -702,7 +769,15 @@ function requireSafeRunId(runId) {
     return normalized;
 }
 function memoryRunFilePath(runId, snapshot, memoryPath) {
-    return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/${snapshot}/${memoryPath.slice(`${MEMORY_ROOT}/`.length)}`;
+    return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/${snapshot}/${memoryPath}`;
+}
+function missingMemoryBlockError(filePath) {
+    return new VcmError({
+        code: "MEMORY_BLOCK_MISSING",
+        message: `VCM memory block is missing from ${filePath}.`,
+        statusCode: 409,
+        hint: "Refresh the VCM Harness in the active task worktree before using Auto Memory."
+    });
 }
 function assertCompleteMemorySet(memory) {
     for (const definition of MEMORY_FILE_DEFINITIONS) {

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

@@ -1,6 +1,6 @@
-import { isGateReviewerRoleName, isHarnessEngineerToolRoleName, isTranslatorToolRoleName, isUserFacingRole, isVcmRoleName } from "../../shared/constants.js";
+import { isGateReviewerRoleName, isHarnessEngineerToolRoleName, isTranslatorToolRoleName, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
-import { readLatestRoleTurnReply, readTranscriptTurnEvidence } from "./claude-transcript-reply.js";
+import { readTranscriptTurnEvidence } from "./claude-transcript-reply.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const MAX_ROLE_RETRY_ATTEMPTS = 20;
@@ -74,12 +74,22 @@ export function createClaudeHookService(deps) {
     async function processTranslatorHook(input) {
         const eventName = parseHookEvent(input.event.hook_event_name);
         const context = await getTranslatorHookContext();
-        const session = await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
-            eventName,
-            sessionId: stringOrUndefined(input.event.session_id),
-            transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
-        });
+        const session = input.taskSlug === "__project__"
+            ? await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
+                eventName,
+                sessionId: stringOrUndefined(input.event.session_id),
+                transcriptPath: stringOrUndefined(input.event.transcript_path),
+                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+            })
+            : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
+                taskSlug: input.taskSlug,
+                role: input.role,
+                eventName,
+                sessionId: stringOrUndefined(input.event.session_id),
+                transcriptPath: stringOrUndefined(input.event.transcript_path),
+                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+                allowSessionMismatch: true
+            });
         await deps.translationWorkerService?.handleTranslatorHook(context.project.repoRoot, eventName, input.taskSlug);
         return {
             ok: true,
@@ -93,15 +103,26 @@ export function createClaudeHookService(deps) {
     async function processHarnessEngineerHook(input) {
         const eventName = parseHookEvent(input.event.hook_event_name);
         const context = await getProjectToolHookContext("Harness Engineer");
-        const session = await deps.sessionService.recordProjectHarnessEngineerHookEvent(context.project.repoRoot, {
-            eventName,
-            sessionId: stringOrUndefined(input.event.session_id),
-            transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
-        });
+        const projectScoped = input.taskSlug === "__project_harness_engineer__";
+        const session = projectScoped
+            ? await deps.sessionService.recordProjectHarnessEngineerHookEvent(context.project.repoRoot, {
+                eventName,
+                sessionId: stringOrUndefined(input.event.session_id),
+                transcriptPath: stringOrUndefined(input.event.transcript_path),
+                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+            })
+            : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
+                taskSlug: input.taskSlug,
+                role: input.role,
+                eventName,
+                sessionId: stringOrUndefined(input.event.session_id),
+                transcriptPath: stringOrUndefined(input.event.transcript_path),
+                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+                allowSessionMismatch: true
+            });
         const activeTask = deps.autoMemoryService
             ? (await deps.taskService.listTasks(context.project.repoRoot))
-                .find((task) => task.cleanupStatus !== "cleaned")
+                .find((task) => task.cleanupStatus !== "cleaned" && (projectScoped || task.taskSlug === input.taskSlug))
             : undefined;
         const memoryHandled = activeTask
             ? await deps.autoMemoryService?.handleHarnessEngineerHook({
@@ -221,13 +242,13 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
-        if (await isDuplicateCompletedStop(context, input)) {
-            return completedHookResult(input, eventName);
-        }
         const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
         if (memoryResult) {
             return memoryResult;
         }
+        if (await isDuplicateCompletedStop(context, input)) {
+            return completedHookResult(input, eventName);
+        }
         await clearStopFailureRecoveryState(context, input.role);
         if (options.allowBlock && deps.jobGuard) {
             const verdict = await deps.jobGuard.evaluateStop({
@@ -381,7 +402,6 @@ export function createClaudeHookService(deps) {
             cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
         if (boundToTask) {
-            const userFacingReply = await captureUserFacingReply(eventName, input.role, session);
             await deps.roundService.recordClaudeHookEvent({
                 repoRoot: context.project.repoRoot,
                 stateRepoRoot: context.taskRepoRoot,
@@ -389,7 +409,6 @@ export function createClaudeHookService(deps) {
                 taskSlug: context.taskSlug,
                 role: input.role,
                 eventName,
-                ...(userFacingReply ? { userFacingReply } : {}),
                 ...(options.settleGuard
                     ? {
                         settleGuard: async () => {
@@ -459,6 +478,17 @@ export function createClaudeHookService(deps) {
             transcriptPath: stringOrUndefined(input.event.transcript_path),
             cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
+        const boundToTask = await isHookSessionBoundToTask(context, input.role);
+        if (boundToTask && eventName !== "PostCompact") {
+            await deps.roundService.recordClaudeHookEvent({
+                repoRoot: context.project.repoRoot,
+                stateRepoRoot: context.taskRepoRoot,
+                stateRoot: context.config.stateRoot,
+                taskSlug: context.taskSlug,
+                role: input.role,
+                eventName
+            });
+        }
         await deps.autoMemoryService.handleRoleHook({
             baseRepoRoot: context.project.repoRoot,
             taskRepoRoot: context.taskRepoRoot,
@@ -755,21 +785,6 @@ function parseHookEvent(value) {
         hint: "VCM accepts UserPromptSubmit, Stop, StopFailure, and PostCompact hooks only."
     });
 }
-// On a user-facing role's Stop, best-effort capture its last user-facing turn
-// text to seed the await-user pause message. Capture failure is non-fatal and
-// must never block turn-end, so a missing/failed read just omits the field.
-async function captureUserFacingReply(eventName, role, session) {
-    if (eventName !== "Stop" || !isUserFacingRole(role) || !session) {
-        return undefined;
-    }
-    try {
-        const reply = await readLatestRoleTurnReply(session);
-        return reply ? { text: reply.text, truncated: reply.truncated } : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 function throwUnsupportedEvent(eventName) {
     throw new VcmError({
         code: "HOOK_EVENT_UNSUPPORTED",

package/dist/backend/services/command-dispatcher.js

@@ -26,7 +26,7 @@ export function createCommandDispatcher(deps) {
                     hint: `Start the ${input.role} session before sending a role command.`
                 });
             }
-            const instruction = `Please read and execute the role command at: ${commandPath}`;
+            const instruction = `[VCM ROLE COMMAND]\nRead and execute the role command at: ${commandPath}\n[/VCM ROLE COMMAND]`;
             await submitTerminalInput(deps.runtime, session.id, instruction);
             return {
                 taskSlug: input.taskSlug,