vibe-coding-master 0.7.5 → 0.7.7

package/dist/backend/services/gate-review-service.js

@@ -16,6 +16,7 @@ const DEFAULT_REPORT_TIMEOUT_MS = 30 * 60 * 1000;
 const activeRuns = new Set();
 const ARCHITECTURE_ANALYSIS_FIELDS = [
     "Evidence Read",
+    "Architecture Brief Fit",
     "End-To-End Flow",
     "Scope Fit",
     "Code Reality",
@@ -54,6 +55,7 @@ const CODE_DIFF_ANALYSIS_FIELDS = [
 ];
 const SOURCE_ARTIFACTS = {
     "architecture-plan": [
+        ".ai/vcm/handoffs/architecture-brief.md",
         ".ai/vcm/handoffs/architecture-plan.md"
     ],
     "validation-adequacy": [
@@ -201,6 +203,32 @@ export function createGateReviewService(deps) {
                 };
             }
         }
+        if (gate === "architecture-plan") {
+            const architectureBriefError = await readArchitectureBriefError(deps.fs, context.taskRepoRoot);
+            if (architectureBriefError) {
+                index = applyGateState(index, gate, {
+                    status: "failed",
+                    decision: undefined,
+                    error: architectureBriefError,
+                    exceptionReason: undefined,
+                    requestId: undefined,
+                    requestPath: undefined,
+                    inputHash: undefined,
+                    requestedAt: undefined,
+                    startedAt: undefined,
+                    completedAt: now(),
+                    callbackStatus: "not_sent",
+                    callbackError: undefined
+                }, now(), true);
+                await saveIndex(deps.fs, context.taskRepoRoot, index);
+                return {
+                    status: "failed_to_start",
+                    gate,
+                    record: index.gates[gate],
+                    message: architectureBriefError
+                };
+            }
+        }
         const coreInput = await readCoreInputArtifact(deps.fs, context.taskRepoRoot, gate);
         if (coreInput && coreInput.status !== "ready") {
             index = applyGateState(index, gate, {
@@ -917,6 +945,22 @@ async function readCoreInputArtifact(fs, taskRepoRoot, gate) {
     }
     return { path: relativePath, status: "ready" };
 }
+async function readArchitectureBriefError(fs, taskRepoRoot) {
+    const relativePath = ".ai/vcm/handoffs/architecture-brief.md";
+    const absolutePath = resolveRepoPath(taskRepoRoot, relativePath);
+    if (!await fs.pathExists(absolutePath)) {
+        return `${relativePath} is missing. Complete Architect Interview before architecture planning.`;
+    }
+    const content = await fs.readText(absolutePath);
+    const check = checkMarkdownArtifact("architecture-brief", relativePath, content);
+    if (check.status !== "ok") {
+        return `${relativePath} is incomplete. Complete and confirm Architect Interview before requesting architecture-plan review.`;
+    }
+    if (!/^\s*Architecture Brief Status\s*:\s*confirmed\s*$/im.test(content)) {
+        return `${relativePath} is not confirmed. Obtain explicit user confirmation before architecture planning.`;
+    }
+    return undefined;
+}
 async function commandStdout(runner, cwd, args) {
     const result = await runner.run("git", args, { cwd });
     return result.exitCode === 0 ? result.stdout : "";

package/dist/backend/services/harness-feedback-service.js

@@ -21,6 +21,23 @@ export function createHarnessFeedbackService(deps) {
             warnings: []
         };
     }
+    async function sendPendingFeedback(repoRoot, input) {
+        await cleanupLegacyState(repoRoot);
+        const feedbackPath = input.feedbackPath.trim();
+        const pending = await listPendingFeedback(repoRoot);
+        const feedback = pending.find((item) => item.path === feedbackPath);
+        if (!feedback) {
+            throw new VcmError({
+                code: "HARNESS_FEEDBACK_NOT_PENDING",
+                message: "The selected Harness Feedback is no longer pending.",
+                statusCode: 404,
+                hint: "Refresh Harness Studio and select a feedback item that is still listed in the Inbox."
+            });
+        }
+        const session = await ensureIdleHarnessEngineer(repoRoot, input.taskSlug);
+        await submitTerminalInput(deps.runtime, session.id, buildPendingFeedbackPrompt(repoRoot, feedback.path));
+        return session;
+    }
     async function startTaskRetrospective(repoRoot, input) {
         await cleanupLegacyState(repoRoot);
         const taskSlug = input.taskSlug.trim();
@@ -76,8 +93,8 @@ export function createHarnessFeedbackService(deps) {
     async function assertHarnessEngineerAvailable(_repoRoot) {
         return undefined;
     }
-    async function ensureIdleHarnessEngineer(repoRoot, taskSlug) {
-        const existing = await deps.sessionService.getProjectHarnessEngineerSession(repoRoot);
+    async function getIdleHarnessEngineer(repoRoot, taskSlug) {
+        const existing = await deps.sessionService.getRoleSession(repoRoot, taskSlug, "harness-engineer");
         if (existing?.status === "running" && existing.activityStatus === "running") {
             throw new VcmError({
                 code: "HARNESS_ENGINEER_BUSY",
@@ -86,12 +103,23 @@ export function createHarnessFeedbackService(deps) {
                 hint: "Wait for the current Harness Engineer turn to finish, then retry."
             });
         }
-        const session = await deps.sessionService.ensureProjectHarnessEngineerSession(repoRoot, {
-            taskSlug,
-            cols: 120,
-            rows: 32
-        });
-        if (session.status !== "running" || session.activityStatus === "running" || !deps.runtime.getSession(session.id)) {
+        const input = { cols: 120, rows: 32 };
+        const session = existing?.status === "running"
+            ? existing
+            : existing?.claudeSessionId
+                ? await deps.sessionService.resumeRoleSession(repoRoot, taskSlug, "harness-engineer", input)
+                : await deps.sessionService.startRoleSession(repoRoot, taskSlug, "harness-engineer", input);
+        if (session.status !== "running" || session.activityStatus === "running") {
+            return undefined;
+        }
+        if (!deps.runtime.getSession(session.id)) {
+            return undefined;
+        }
+        return session;
+    }
+    async function ensureIdleHarnessEngineer(repoRoot, taskSlug) {
+        const session = await getIdleHarnessEngineer(repoRoot, taskSlug);
+        if (!session) {
             throw new VcmError({
                 code: "HARNESS_ENGINEER_BUSY",
                 message: "Harness Engineer is busy or unavailable.",
@@ -144,6 +172,16 @@ export function createHarnessFeedbackService(deps) {
             "End your turn after writing the result."
         ].join("\n");
     }
+    function buildPendingFeedbackPrompt(repoRoot, feedbackPath) {
+        return [
+            "[VCM Harness Feedback]",
+            "",
+            "Review this feedback:",
+            resolveRepoPath(repoRoot, feedbackPath),
+            "",
+            "Verify the issue against the current harness and project evidence. Report your findings and proposed changes to the user."
+        ].join("\n");
+    }
     async function loadTaskRetrospectiveMarker(repoRoot, taskSlug) {
         const markerPath = resolveRepoPath(repoRoot, getTaskRetrospectiveMarkerPath(taskSlug));
         if (!(await deps.fs.pathExists(markerPath))) {
@@ -174,6 +212,7 @@ export function createHarnessFeedbackService(deps) {
     }
     return {
         getState,
+        sendPendingFeedback,
         startTaskRetrospective,
         assertHarnessEngineerAvailable
     };

package/dist/backend/services/harness-service.js

@@ -8,18 +8,21 @@ import { renderGateReviewerAgentRules, renderRequestGateReviewTool, renderTransl
 import { renderHarnessEngineerHarnessRules } from "../templates/harness/harness-engineer-agent.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
 import { renderGitignoreHarnessRules } from "../templates/harness/gitignore.js";
+import { ensureVcmMemoryBlock } from "../templates/harness/memory-block.js";
 import { renderLegacyProjectCodingStandardsTemplate, renderProjectCodingStandardsProjectSection, renderProjectCodingStandardsRules } from "../templates/harness/project-coding-standards.js";
 import { renderProjectGlossaryTemplate } from "../templates/harness/project-glossary.js";
 import { renderLegacyProjectKnownIssuesTemplate, renderProjectKnownIssuesRules, renderProjectKnownIssuesSection } from "../templates/harness/project-known-issues.js";
 import { renderProjectManagerHarnessRules } from "../templates/harness/project-manager-agent.js";
 import { renderPullRequestTemplateHarnessRules } from "../templates/harness/pull-request-template.js";
 import { renderTesterHarnessRules } from "../templates/harness/tester-agent.js";
+import { renderVcmArchitectureInterviewSkillRules } from "../templates/harness/vcm-architecture-interview-skill.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 { renderUpdateTaskStateTool, renderVcmTaskStateSkillRules } from "../templates/harness/vcm-task-state-skill.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { VcmError } from "../errors.js";
 import { bumpHarnessRevision, readHarnessRevisionState } from "./harness-revision.js";
@@ -57,6 +60,7 @@ const HARNESS_FILES = [
         path: "CLAUDE.md",
         title: "CLAUDE.md",
         blankLineBeforeEnd: true,
+        memoryBlock: true,
         renderRules: renderRootClaudeHarnessRules
     },
     {
@@ -95,6 +99,14 @@ const HARNESS_FILES = [
         title: "Pull Request Template",
         renderRules: renderPullRequestTemplateHarnessRules
     },
+    {
+        kind: "skill-vcm-architecture-interview",
+        path: ".claude/skills/vcm-architecture-interview/SKILL.md",
+        title: "VCM Architecture Interview Skill",
+        frontmatter: renderSkillFrontmatter("vcm-architecture-interview", "Use when Architect must confirm user-owned behavior and contract decisions before architecture planning."),
+        ownership: "whole-file",
+        renderRules: renderVcmArchitectureInterviewSkillRules
+    },
     {
         kind: "skill-vcm-route-message",
         path: ".claude/skills/vcm-route-message/SKILL.md",
@@ -103,6 +115,14 @@ const HARNESS_FILES = [
         ownership: "whole-file",
         renderRules: renderVcmRouteMessageSkillRules
     },
+    {
+        kind: "skill-vcm-task-state",
+        path: ".claude/skills/vcm-task-state/SKILL.md",
+        title: "VCM Task State Skill",
+        frontmatter: renderSkillFrontmatter("vcm-task-state", "Use only as project-manager to declare the current task workflow checkpoint to VCM."),
+        ownership: "whole-file",
+        renderRules: renderVcmTaskStateSkillRules
+    },
     {
         kind: "skill-vcm-final-acceptance",
         path: ".claude/skills/vcm-final-acceptance/SKILL.md",
@@ -155,6 +175,7 @@ const HARNESS_FILES = [
         kind: "agent-gate-reviewer",
         path: ".claude/agents/gate-reviewer.md",
         title: "Gate Reviewer Agent",
+        memoryBlock: true,
         frontmatter: renderAgentFrontmatter("gate-reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.", { tools: "Read, Grep, Glob, Bash, Write" }),
         renderRules: renderGateReviewerAgentRules
     },
@@ -162,14 +183,15 @@ const HARNESS_FILES = [
         kind: "agent-translator",
         path: ".claude/agents/translator.md",
         title: "Translator Agent",
-        frontmatter: renderAgentFrontmatter("translator", "VCM project translation tool role for conversation translation, file translation, bootstrap, and memory updates."),
+        frontmatter: renderAgentFrontmatter("translator", "VCM task-scoped translation tool role for conversation translation, file translation, bootstrap, and memory updates."),
         renderRules: renderTranslatorAgentRules
     },
     {
         kind: "agent-harness-engineer",
         path: ".claude/agents/harness-engineer.md",
         title: "Harness Engineer Agent",
-        frontmatter: renderAgentFrontmatter("harness-engineer", "VCM project-scoped harness maintenance role for harness diagnosis, diff proposals, and VCM issue drafts."),
+        memoryBlock: true,
+        frontmatter: renderAgentFrontmatter("harness-engineer", "VCM task-scoped harness maintenance role for harness diagnosis, diff proposals, and VCM issue drafts."),
         renderRules: renderHarnessEngineerHarnessRules
     },
     {
@@ -186,10 +208,18 @@ const HARNESS_FILES = [
         ownership: "raw-file",
         renderRules: renderRequestGateReviewTool
     },
+    {
+        kind: "tool-update-task-state",
+        path: ".ai/tools/update-task-state",
+        title: "Update Task State Tool",
+        ownership: "raw-file",
+        renderRules: renderUpdateTaskStateTool
+    },
     {
         kind: "agent-project-manager",
         path: ".claude/agents/project-manager.md",
         title: "Project Manager Agent",
+        memoryBlock: true,
         frontmatter: renderAgentFrontmatter("project-manager", "User-facing VCM orchestration role for task clarification, role routing, handoffs, acceptance, and PR preparation."),
         renderRules: renderProjectManagerHarnessRules
     },
@@ -197,6 +227,7 @@ const HARNESS_FILES = [
         kind: "agent-architect",
         path: ".claude/agents/architect.md",
         title: "Architect Agent",
+        memoryBlock: true,
         blankLineBeforeEnd: true,
         frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync."),
         renderRules: renderArchitectHarnessRules
@@ -205,6 +236,7 @@ const HARNESS_FILES = [
         kind: "agent-coder",
         path: ".claude/agents/coder.md",
         title: "Coder Agent",
+        memoryBlock: true,
         frontmatter: renderAgentFrontmatter("coder", "VCM implementation role for scoped code changes and focused tests.", { tools: "Read, Grep, Glob, Bash, Edit, Write, Agent" }),
         renderRules: renderCoderHarnessRules
     },
@@ -212,6 +244,7 @@ const HARNESS_FILES = [
         kind: "agent-tester",
         path: ".claude/agents/tester.md",
         title: "Tester Agent",
+        memoryBlock: true,
         frontmatter: renderAgentFrontmatter("tester", "VCM testing role for validation, test adequacy, approved-scope validation, and risk findings."),
         renderRules: renderTesterHarnessRules
     }
@@ -316,12 +349,12 @@ export function createHarnessService(deps) {
         async mergeRepositoryDiffToCurrentBranch(baseRepoRoot, input) {
             return mergeRepositoryDiffToCurrentBranch(requireRepositoryMergeGit(deps.git), baseRepoRoot, input, now());
         },
-        async getBootstrapStatus(repoRoot, targetRepoRoot = repoRoot) {
-            return getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
+        async getBootstrapStatus(repoRoot, targetRepoRoot = repoRoot, taskSlug) {
+            return getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion, taskSlug);
         },
         async startHarnessBootstrap(repoRoot, targetRepoRoot = repoRoot, input = {}) {
             const session = await ensureHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, vcmVersion, input);
-            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
+            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion, input.taskSlug);
             return {
                 status: {
                     ...nextStatus,
@@ -333,7 +366,7 @@ export function createHarnessService(deps) {
         },
         async restartHarnessBootstrap(repoRoot, targetRepoRoot = repoRoot, input = {}) {
             const session = await restartHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, vcmVersion, input);
-            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
+            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion, input.taskSlug);
             return {
                 status: {
                     ...nextStatus,
@@ -343,8 +376,8 @@ export function createHarnessService(deps) {
                 prompt: buildHarnessBootstrapPrompt(repoRoot, targetRepoRoot)
             };
         },
-        async stopHarnessBootstrap(repoRoot) {
-            const existing = await getCurrentHarnessEngineerBootstrapSession(deps, repoRoot);
+        async stopHarnessBootstrap(repoRoot, targetRepoRoot = repoRoot, taskSlug) {
+            const existing = await getCurrentHarnessEngineerBootstrapSession(deps, repoRoot, taskSlug);
             if (!existing) {
                 throw new VcmError({
                     code: "HARNESS_BOOTSTRAP_SESSION_MISSING",
@@ -352,11 +385,13 @@ export function createHarnessService(deps) {
                     statusCode: 404
                 });
             }
-            await deps.harnessEngineerSessions?.stopProjectHarnessEngineerSession(repoRoot);
+            if (taskSlug) {
+                await deps.harnessEngineerSessions?.stopRoleSession(repoRoot, taskSlug, "harness-engineer");
+            }
             await clearHarnessBootstrapRunState(deps.fs, repoRoot);
-            return getHarnessBootstrapStatus(deps, repoRoot, repoRoot, now, vcmVersion);
+            return getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion, taskSlug);
         },
-        async runHarnessBootstrap(repoRoot, targetRepoRoot = repoRoot) {
+        async runHarnessBootstrap(repoRoot, targetRepoRoot = repoRoot, taskSlug) {
             if (!deps.runtime || !deps.harnessEngineerSessions) {
                 throw new VcmError({
                     code: "HARNESS_BOOTSTRAP_UNAVAILABLE",
@@ -365,7 +400,7 @@ export function createHarnessService(deps) {
                 });
             }
             await assertHarnessWorktreeClean(deps.git, targetRepoRoot);
-            const status = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
+            const status = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion, taskSlug);
             const session = status.session;
             if (!session || session.status !== "running" || !deps.runtime.getSession(session.id)) {
                 throw new VcmError({
@@ -379,6 +414,7 @@ export function createHarnessService(deps) {
             await persistHarnessBootstrapRunState(deps.fs, repoRoot, {
                 version: 1,
                 status: "running",
+                taskSlug,
                 targetRepoRoot,
                 sessionId: session.id,
                 claudeSessionId: session.claudeSessionId,
@@ -386,7 +422,7 @@ export function createHarnessService(deps) {
                 updatedAt: timestamp
             });
             await submitTerminalInput(deps.runtime, session.id, prompt);
-            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
+            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion, taskSlug);
             return {
                 status: {
                     ...nextStatus,
@@ -400,7 +436,7 @@ export function createHarnessService(deps) {
         async recordHarnessBootstrapHook(repoRoot, input) {
             const state = await loadPersistedHarnessBootstrapRunState(deps.fs, repoRoot);
             if (state?.status !== "running" || !matchesBootstrapRunState(state, input)) {
-                return getHarnessBootstrapStatus(deps, repoRoot, state?.targetRepoRoot ?? repoRoot, now, vcmVersion);
+                return getHarnessBootstrapStatus(deps, repoRoot, state?.targetRepoRoot ?? repoRoot, now, vcmVersion, state?.taskSlug);
             }
             const timestamp = now();
             if (input.eventName === "Stop" && state.targetRepoRoot) {
@@ -413,7 +449,7 @@ export function createHarnessService(deps) {
                 updatedAt: timestamp,
                 lastHookEvent: input.eventName
             });
-            return getHarnessBootstrapStatus(deps, repoRoot, state.targetRepoRoot ?? repoRoot, now, vcmVersion);
+            return getHarnessBootstrapStatus(deps, repoRoot, state.targetRepoRoot ?? repoRoot, now, vcmVersion, state.taskSlug);
         }
     };
 }
@@ -425,7 +461,8 @@ async function ensureHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot,
             statusCode: 501
         });
     }
-    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
+    const taskSlug = requireHarnessEngineerTaskSlug(input.taskSlug);
+    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion, taskSlug);
     if (currentStatus.session?.status === "running") {
         return currentStatus.session;
     }
@@ -436,7 +473,14 @@ async function ensureHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot,
             statusCode: 409
         });
     }
-    return toHarnessBootstrapSession(await deps.harnessEngineerSessions.ensureProjectHarnessEngineerSession(repoRoot, input));
+    const existing = await deps.harnessEngineerSessions.getRoleSession(repoRoot, taskSlug, "harness-engineer");
+    if (existing?.status === "running") {
+        return toHarnessBootstrapSession(existing);
+    }
+    if (existing?.claudeSessionId) {
+        return toHarnessBootstrapSession(await deps.harnessEngineerSessions.resumeRoleSession(repoRoot, taskSlug, "harness-engineer", input));
+    }
+    return toHarnessBootstrapSession(await deps.harnessEngineerSessions.startRoleSession(repoRoot, taskSlug, "harness-engineer", input));
 }
 async function restartHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, vcmVersion, input) {
     if (!deps.harnessEngineerSessions) {
@@ -446,7 +490,8 @@ async function restartHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot
             statusCode: 501
         });
     }
-    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
+    const taskSlug = requireHarnessEngineerTaskSlug(input.taskSlug);
+    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion, taskSlug);
     if (!currentStatus.canStart) {
         throw new VcmError({
             code: "HARNESS_BOOTSTRAP_NOT_READY",
@@ -454,12 +499,27 @@ async function restartHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot
             statusCode: 409
         });
     }
-    return toHarnessBootstrapSession(await deps.harnessEngineerSessions.restartProjectHarnessEngineerSession(repoRoot, input));
+    return toHarnessBootstrapSession(await deps.harnessEngineerSessions.restartRoleSession(repoRoot, taskSlug, "harness-engineer", input));
 }
-async function getCurrentHarnessEngineerBootstrapSession(deps, repoRoot) {
-    const session = await deps.harnessEngineerSessions?.getProjectHarnessEngineerSession(repoRoot);
+async function getCurrentHarnessEngineerBootstrapSession(deps, repoRoot, taskSlug) {
+    if (!taskSlug) {
+        return undefined;
+    }
+    const session = await deps.harnessEngineerSessions?.getRoleSession(repoRoot, taskSlug, "harness-engineer");
     return session ? toHarnessBootstrapSession(session) : undefined;
 }
+function requireHarnessEngineerTaskSlug(value) {
+    const taskSlug = value?.trim();
+    if (!taskSlug) {
+        throw new VcmError({
+            code: "HARNESS_ENGINEER_TASK_REQUIRED",
+            message: "Harness Engineer requires an active task.",
+            statusCode: 409,
+            hint: "Create or select a task before using Harness Engineer."
+        });
+    }
+    return taskSlug;
+}
 function toHarnessBootstrapSession(session) {
     return {
         id: session.id,
@@ -1059,6 +1119,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
         : getManagedBlockPattern(definition);
     const exists = await fs.pathExists(absolutePath);
     if (!exists) {
+        const newContent = expectedContent ?? renderNewHarnessFile(definition, expectedBlock ?? "");
         return {
             definition,
             status: {
@@ -1073,7 +1134,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
                 action: "create",
                 reason: "File is missing; VCM will create a recommended default."
             },
-            nextContent: expectedContent ?? renderNewHarnessFile(definition, expectedBlock ?? "")
+            nextContent: definition.memoryBlock ? ensureVcmMemoryBlock(newContent) : newContent
         };
     }
     const currentContent = await fs.readText(absolutePath);
@@ -1105,6 +1166,7 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
     if (!match) {
         const migratedContent = migrateLegacyHarnessFile(definition, currentContent, expectedBlock);
         if (migratedContent) {
+            const nextContent = definition.memoryBlock ? ensureVcmMemoryBlock(migratedContent) : migratedContent;
             return {
                 definition,
                 status: {
@@ -1119,9 +1181,10 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
                     action: "update",
                     reason: "Legacy VCM whole-file baseline will be migrated to a managed block."
                 },
-                nextContent: migratedContent
+                nextContent
             };
         }
+        const insertedContent = `${currentContent.trimEnd()}\n\n${expectedBlock}\n`;
         return {
             definition,
             status: {
@@ -1136,12 +1199,14 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
                 action: "insert",
                 reason: "File exists but does not contain VCM managed rules."
             },
-            nextContent: `${currentContent.trimEnd()}\n\n${expectedBlock}\n`
+            nextContent: definition.memoryBlock ? ensureVcmMemoryBlock(insertedContent) : insertedContent
         };
     }
     const managedVersion = match[1] ? Number(match[1]) : undefined;
     const currentBlock = match[0];
-    const action = currentBlock === expectedBlock ? "ok" : "update";
+    const blockUpdatedContent = currentContent.replace(managedBlockPattern, expectedBlock);
+    const nextContent = definition.memoryBlock ? ensureVcmMemoryBlock(blockUpdatedContent) : blockUpdatedContent;
+    const action = currentContent === nextContent ? "ok" : "update";
     return {
         definition,
         status: {
@@ -1157,13 +1222,15 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
             : {
                 path: definition.path,
                 action,
-                reason: managedVersion === VCM_HARNESS_VERSION
-                    ? "VCM managed rules differ from the current recommended template."
-                    : `VCM managed block version is ${managedVersion ?? "missing"}; current version is ${VCM_HARNESS_VERSION}.`
+                reason: currentBlock === expectedBlock && definition.memoryBlock
+                    ? "VCM memory block is missing."
+                    : managedVersion === VCM_HARNESS_VERSION
+                        ? "VCM managed rules differ from the current recommended template."
+                        : `VCM managed block version is ${managedVersion ?? "missing"}; current version is ${VCM_HARNESS_VERSION}.`
             },
         nextContent: action === "ok"
             ? undefined
-            : currentContent.replace(managedBlockPattern, expectedBlock)
+            : nextContent
     };
 }
 async function analyzeLegacyCodexHarnessPaths(fs, repoRoot) {
@@ -1417,7 +1484,7 @@ async function analyzeHarnessManifest(fs, repoRoot, vcmVersion) {
     }
     return undefined;
 }
-async function getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion) {
+async function getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion, taskSlug) {
     const moduleIndex = await readOptionalJsonObject(deps.fs, targetRepoRoot, ".ai/generated/module-index.json");
     const checks = [
         await checkFixedHarness(deps.fs, targetRepoRoot, vcmVersion),
@@ -1430,8 +1497,11 @@ async function getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vc
         await checkModuleArchitectureDocs(deps.fs, targetRepoRoot, moduleIndex),
         await checkFilledMarkdown(deps.fs, targetRepoRoot, "docs/TESTING.md", "Testing doc", "testing-doc")
     ];
-    const runState = await loadPersistedHarnessBootstrapRunState(deps.fs, repoRoot);
-    const session = await getCurrentHarnessEngineerBootstrapSession(deps, repoRoot);
+    const persistedRunState = await loadPersistedHarnessBootstrapRunState(deps.fs, repoRoot);
+    const runState = taskSlug && persistedRunState?.taskSlug !== taskSlug
+        ? undefined
+        : persistedRunState;
+    const session = await getCurrentHarnessEngineerBootstrapSession(deps, repoRoot, taskSlug);
     const fixedHarnessReady = checks[0]?.status === "ok";
     const projectChecks = checks.slice(1);
     const projectComplete = projectChecks.every((check) => check.status === "ok");
@@ -1461,6 +1531,7 @@ async function checkFixedHarness(fs, repoRoot, vcmVersion) {
         ".claude/skills/vcm-harness-bootstrap/SKILL.md",
         "docs/GLOSSARY.md",
         "docs/CODING_STANDARDS.md",
+        ".ai/tools/check-durable-docs",
         ".ai/tools/generate-module-index",
         ".ai/tools/generate-public-surface"
     ];
@@ -1680,6 +1751,8 @@ async function loadPersistedHarnessBootstrapRunState(fs, repoRoot) {
     return {
         version: 1,
         status,
+        taskSlug: typeof payload.taskSlug === "string" ? payload.taskSlug : undefined,
+        targetRepoRoot: typeof payload.targetRepoRoot === "string" ? payload.targetRepoRoot : undefined,
         sessionId: typeof payload.sessionId === "string" ? payload.sessionId : undefined,
         claudeSessionId: typeof payload.claudeSessionId === "string" ? payload.claudeSessionId : undefined,
         startedAt: typeof payload.startedAt === "string" ? payload.startedAt : undefined,
@@ -1746,7 +1819,9 @@ function bootstrapWarnings(status, checks, session, runState) {
     return warnings;
 }
 function buildHarnessBootstrapPrompt(baseRepoRoot, targetRepoRoot) {
-    return `Use the vcm-harness-bootstrap skill to finish the VCM harness bootstrap for the active task worktree.
+    return `[VCM HARNESS BOOTSTRAP]
+
+Use the vcm-harness-bootstrap skill to finish the VCM harness bootstrap for the active task worktree.
 
 Base repository root:
 ${baseRepoRoot}
@@ -1764,6 +1839,7 @@ Required work:
 - Fill target docs/ARCHITECTURE.md with project-level module overview, responsibilities, relationships, dependency direction, project-wide constraints, and links to module-level architecture docs.
 - Create or update target module-level ARCHITECTURE.md files for clear non-root module boundaries with architectureDoc paths in module-index.json.
 - Fill target docs/TESTING.md with project-native validation levels, commands, validation selection rules, final-validation cleanup, test layout, integration/E2E case lists, generated-context freshness checks, and known testing gaps.
+- Run .ai/tools/check-durable-docs and correct every bootstrap-owned finding.
 - Review git status and git diff in the target task worktree.
 - Stage only allowed bootstrap harness changes and create a commit in the target task worktree.
 
@@ -1775,7 +1851,9 @@ Boundaries:
 - VCM will not create the bootstrap commit for you.
 
 Final response:
-Summarize files reviewed, files updated, generated artifacts, commit hash, final git status, verified claims, inferred claims, unknowns, confirmation-needed items, and suggested validation commands.`;
+Summarize files reviewed, files updated, generated artifacts, durable-doc audit result, commit hash, final git status, verified claims, inferred claims, unknowns, confirmation-needed items, and suggested validation commands.
+
+[/VCM HARNESS BOOTSTRAP]`;
 }
 export function createScriptFixedHarnessInstaller(scriptPath = path.resolve(process.cwd(), "scripts/install-vcm-harness.mjs")) {
     return async (repoRoot) => {