vibe-coding-master 0.3.32 → 0.4.1

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

@@ -1,10 +1,10 @@
-import { randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
 import path from "node:path";
 import { promisify } from "node:util";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
 import { renderGateReviewerAgentRules, renderRequestGateReviewTool, renderTranslatorAgentRules, renderVcmGateReviewSkillRules } from "../templates/harness/gate-review.js";
+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 { renderProjectManagerHarnessRules } from "../templates/harness/project-manager-agent.js";
@@ -16,11 +16,10 @@ import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/v
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-skill.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { VcmError } from "../errors.js";
+import { bumpHarnessRevision, readHarnessRevisionState } from "./harness-revision.js";
 const execFileAsync = promisify(execFile);
-const BOOTSTRAP_TASK_SLUG = "__vcm-harness-bootstrap__";
-const BOOTSTRAP_RUNTIME_ROLE = "project-manager";
-const BOOTSTRAP_LOG_PATH = ".ai/vcm/bootstrap/bootstrap.log";
 const BOOTSTRAP_SESSION_PATH = ".ai/vcm/bootstrap/session.json";
+const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
 export const VCM_HARNESS_VERSION = 1;
 const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!-- VCM:END -->/m;
 const HASH_MANAGED_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=(\d+))?\n[\s\S]*?# VCM:END/m;
@@ -119,6 +118,13 @@ const HARNESS_FILES = [
         frontmatter: renderAgentFrontmatter("translator", "VCM project 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."),
+        renderRules: renderHarnessEngineerHarnessRules
+    },
     {
         kind: "tool-request-gate-review",
         path: ".ai/tools/request-gate-review",
@@ -162,11 +168,46 @@ export function createHarnessService(deps) {
         async getHarnessStatus(repoRoot) {
             const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
             const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
-            return renderHarnessStatus(analyses, legacyChanges);
+            return renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges);
+        },
+        async getHarnessFileContent(repoRoot, filePath) {
+            return readHarnessFileContent(deps.fs, repoRoot, filePath);
+        },
+        async updateHarnessFileContent(repoRoot, filePath, content) {
+            const definition = getHarnessFileDefinition(filePath);
+            if (!isProjectEditableHarnessFile(definition)) {
+                throw new VcmError({
+                    code: "HARNESS_FILE_READONLY",
+                    message: "This harness file is managed by VCM and cannot be edited directly.",
+                    statusCode: 409,
+                    hint: getReadonlyHarnessReason(definition)
+                });
+            }
+            const absolutePath = resolveHarnessPath(repoRoot, definition.path);
+            const currentContent = await deps.fs.pathExists(absolutePath)
+                ? await deps.fs.readText(absolutePath)
+                : "";
+            assertManagedBlockUnchanged(definition, currentContent, content);
+            const nextContent = ensureTrailingNewline(content);
+            await deps.fs.writeText(absolutePath, nextContent);
+            if (nextContent !== currentContent) {
+                await bumpHarnessRevision(deps.fs, repoRoot, now());
+            }
+            const file = await readHarnessFileContent(deps.fs, repoRoot, definition.path);
+            const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
+            const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
+            return {
+                file,
+                status: renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges)
+            };
         },
         async applyHarness(repoRoot) {
             if (deps.runFixedInstaller) {
-                return deps.runFixedInstaller(repoRoot);
+                const result = await deps.runFixedInstaller(repoRoot);
+                if (result.changedFiles.length > 0) {
+                    await bumpHarnessRevision(deps.fs, repoRoot, now());
+                }
+                return result;
             }
             const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
             const changedFiles = [];
@@ -181,6 +222,9 @@ export function createHarnessService(deps) {
             }
             const legacyChanges = await removeLegacyCodexHarnessPaths(deps.fs, repoRoot);
             changedFiles.push(...legacyChanges);
+            if (changedFiles.length > 0) {
+                await bumpHarnessRevision(deps.fs, repoRoot, now());
+            }
             return {
                 version: VCM_HARNESS_VERSION,
                 changedFiles,
@@ -260,64 +304,70 @@ export function createHarnessService(deps) {
             return getHarnessBootstrapStatus(deps, repoRoot, now);
         },
         async startHarnessBootstrap(repoRoot, input = {}) {
-            if (!deps.runtime || !deps.projectService) {
+            const session = await ensureHarnessEngineerForBootstrap(deps, repoRoot, now, input);
+            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
+            return {
+                status: {
+                    ...nextStatus,
+                    session
+                },
+                session,
+                prompt: buildHarnessBootstrapPrompt(repoRoot)
+            };
+        },
+        async restartHarnessBootstrap(repoRoot, input = {}) {
+            const session = await restartHarnessEngineerForBootstrap(deps, repoRoot, now, input);
+            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
+            return {
+                status: {
+                    ...nextStatus,
+                    session
+                },
+                session,
+                prompt: buildHarnessBootstrapPrompt(repoRoot)
+            };
+        },
+        async stopHarnessBootstrap(repoRoot) {
+            const existing = await getCurrentHarnessEngineerBootstrapSession(deps, repoRoot);
+            if (!existing) {
+                throw new VcmError({
+                    code: "HARNESS_BOOTSTRAP_SESSION_MISSING",
+                    message: "Harness Engineer session has not been started.",
+                    statusCode: 404
+                });
+            }
+            await deps.harnessEngineerSessions?.stopProjectHarnessEngineerSession(repoRoot);
+            await clearHarnessBootstrapRunState(deps.fs, repoRoot);
+            return getHarnessBootstrapStatus(deps, repoRoot, now);
+        },
+        async runHarnessBootstrap(repoRoot) {
+            if (!deps.runtime || !deps.harnessEngineerSessions) {
                 throw new VcmError({
                     code: "HARNESS_BOOTSTRAP_UNAVAILABLE",
                     message: "Harness bootstrap sessions are not available in this VCM runtime.",
                     statusCode: 501
                 });
             }
-            const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
-            if (currentStatus.session?.status === "running") {
-                return {
-                    status: currentStatus,
-                    session: currentStatus.session,
-                    prompt: buildHarnessBootstrapPrompt(repoRoot)
-                };
-            }
-            if (!currentStatus.canStart) {
+            const status = await getHarnessBootstrapStatus(deps, repoRoot, now);
+            const session = status.session;
+            if (!session || session.status !== "running" || !deps.runtime.getSession(session.id)) {
                 throw new VcmError({
-                    code: "HARNESS_BOOTSTRAP_NOT_READY",
-                    message: "Install the fixed VCM harness before running harness bootstrap.",
+                    code: "HARNESS_BOOTSTRAP_SESSION_NOT_RUNNING",
+                    message: "Start the Harness Engineer session before running bootstrap.",
                     statusCode: 409
                 });
             }
-            const config = await deps.projectService.loadConfig(repoRoot);
-            const claudeSessionId = randomUUID();
-            const command = buildClaudeStartCommand(config.claudeCommand, "default", claudeSessionId);
-            const logPath = path.join(repoRoot, BOOTSTRAP_LOG_PATH);
-            const runtimeSession = await deps.runtime.createSession({
-                taskSlug: BOOTSTRAP_TASK_SLUG,
-                role: BOOTSTRAP_RUNTIME_ROLE,
-                command: command.command,
-                args: command.args,
-                cwd: repoRoot,
-                env: {
-                    VCM_API_URL: deps.apiUrl,
-                    VCM_TASK_REPO_ROOT: repoRoot,
-                    VCM_HARNESS_BOOTSTRAP: "1",
-                    VCM_SESSION_ID: claudeSessionId
-                },
-                cols: input.cols,
-                rows: input.rows,
-                logPath
-            });
-            const timestamp = now();
-            const session = {
-                id: runtimeSession.id,
-                claudeSessionId,
-                status: runtimeSession.status === "crashed" ? "crashed" : runtimeSession.status === "exited" ? "exited" : "running",
-                command: command.display,
-                cwd: repoRoot,
-                logPath: BOOTSTRAP_LOG_PATH,
-                startedAt: runtimeSession.startedAt,
-                updatedAt: timestamp,
-                lastOutputAt: runtimeSession.lastOutputAt,
-                exitCode: runtimeSession.exitCode
-            };
-            await persistHarnessBootstrapSession(deps.fs, repoRoot, session);
             const prompt = buildHarnessBootstrapPrompt(repoRoot);
-            await submitTerminalInput(deps.runtime, runtimeSession.id, prompt);
+            const timestamp = now();
+            await persistHarnessBootstrapRunState(deps.fs, repoRoot, {
+                version: 1,
+                status: "running",
+                sessionId: session.id,
+                claudeSessionId: session.claudeSessionId,
+                startedAt: timestamp,
+                updatedAt: timestamp
+            });
+            await submitTerminalInput(deps.runtime, session.id, prompt);
             const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
             return {
                 status: {
@@ -327,6 +377,21 @@ export function createHarnessService(deps) {
                 session,
                 prompt
             };
+        },
+        async recordHarnessBootstrapHook(repoRoot, input) {
+            const state = await loadPersistedHarnessBootstrapRunState(deps.fs, repoRoot);
+            if (state?.status !== "running" || !matchesBootstrapRunState(state, input)) {
+                return getHarnessBootstrapStatus(deps, repoRoot, now);
+            }
+            const timestamp = now();
+            await persistHarnessBootstrapRunState(deps.fs, repoRoot, {
+                ...state,
+                status: input.eventName === "Stop" ? "complete" : state.status,
+                completedAt: input.eventName === "Stop" ? timestamp : state.completedAt,
+                updatedAt: timestamp,
+                lastHookEvent: input.eventName
+            });
+            return getHarnessBootstrapStatus(deps, repoRoot, now);
         }
     };
 }
@@ -346,6 +411,72 @@ function dedupeHarnessChanges(changedFiles) {
     }
     return changes;
 }
+async function ensureHarnessEngineerForBootstrap(deps, repoRoot, now, input) {
+    if (!deps.harnessEngineerSessions) {
+        throw new VcmError({
+            code: "HARNESS_BOOTSTRAP_UNAVAILABLE",
+            message: "Harness bootstrap sessions are not available in this VCM runtime.",
+            statusCode: 501
+        });
+    }
+    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
+    if (currentStatus.session?.status === "running") {
+        return currentStatus.session;
+    }
+    if (!currentStatus.canStart) {
+        throw new VcmError({
+            code: "HARNESS_BOOTSTRAP_NOT_READY",
+            message: "Install the fixed VCM harness before starting harness bootstrap.",
+            statusCode: 409
+        });
+    }
+    return toHarnessBootstrapSession(await deps.harnessEngineerSessions.ensureProjectHarnessEngineerSession(repoRoot, input));
+}
+async function restartHarnessEngineerForBootstrap(deps, repoRoot, now, input) {
+    if (!deps.harnessEngineerSessions) {
+        throw new VcmError({
+            code: "HARNESS_BOOTSTRAP_UNAVAILABLE",
+            message: "Harness bootstrap sessions are not available in this VCM runtime.",
+            statusCode: 501
+        });
+    }
+    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
+    if (!currentStatus.canStart) {
+        throw new VcmError({
+            code: "HARNESS_BOOTSTRAP_NOT_READY",
+            message: "Install the fixed VCM harness before starting harness bootstrap.",
+            statusCode: 409
+        });
+    }
+    return toHarnessBootstrapSession(await deps.harnessEngineerSessions.restartProjectHarnessEngineerSession(repoRoot, input));
+}
+async function getCurrentHarnessEngineerBootstrapSession(deps, repoRoot) {
+    const session = await deps.harnessEngineerSessions?.getProjectHarnessEngineerSession(repoRoot);
+    return session ? toHarnessBootstrapSession(session) : undefined;
+}
+function toHarnessBootstrapSession(session) {
+    return {
+        id: session.id,
+        claudeSessionId: session.claudeSessionId,
+        status: toBootstrapSessionStatus(session.status),
+        command: session.command,
+        permissionMode: session.permissionMode,
+        model: session.model,
+        effort: session.effort,
+        cwd: session.cwd,
+        logPath: HARNESS_ENGINEER_SESSION_PATH,
+        startedAt: session.startedAt,
+        updatedAt: session.updatedAt,
+        lastOutputAt: session.lastOutputAt,
+        exitCode: session.exitCode
+    };
+}
+function toBootstrapSessionStatus(status) {
+    if (status === "running" || status === "crashed" || status === "exited" || status === "resumable") {
+        return status;
+    }
+    return status === "missing" ? "resumable" : "exited";
+}
 function normalizeHarnessGitPath(value) {
     if (!value || value.includes("\0") || path.posix.isAbsolute(value)) {
         throw new VcmError({
@@ -369,6 +500,104 @@ function normalizeHarnessGitPath(value) {
 function shortCommit(commit) {
     return commit.slice(0, 7);
 }
+async function readHarnessFileContent(fs, repoRoot, filePath) {
+    const definition = getHarnessFileDefinition(filePath);
+    const absolutePath = resolveHarnessPath(repoRoot, definition.path);
+    const exists = await fs.pathExists(absolutePath);
+    const content = exists ? await fs.readText(absolutePath) : "";
+    const editable = isProjectEditableHarnessFile(definition);
+    return {
+        path: definition.path,
+        kind: definition.kind,
+        title: definition.title,
+        content,
+        editable,
+        readonlyReason: editable ? undefined : getReadonlyHarnessReason(definition)
+    };
+}
+function getHarnessFileDefinition(filePath) {
+    const normalizedPath = normalizeHarnessFilePath(filePath);
+    const definition = HARNESS_FILES.find((file) => file.path === normalizedPath) ?? getSpecialHarnessFileDefinition(normalizedPath);
+    if (!definition) {
+        throw new VcmError({
+            code: "HARNESS_FILE_UNKNOWN",
+            message: "This path is not a known VCM harness file.",
+            statusCode: 404,
+            hint: normalizedPath
+        });
+    }
+    return definition;
+}
+function getSpecialHarnessFileDefinition(filePath) {
+    if (filePath !== CLAUDE_SETTINGS_PATH) {
+        return undefined;
+    }
+    return {
+        kind: "claude-settings",
+        path: CLAUDE_SETTINGS_PATH,
+        title: "Claude Code Settings",
+        ownership: "raw-file",
+        renderRules: () => ""
+    };
+}
+function normalizeHarnessFilePath(filePath) {
+    if (!filePath || filePath.includes("\0") || path.posix.isAbsolute(filePath)) {
+        throw new VcmError({
+            code: "HARNESS_FILE_PATH_INVALID",
+            message: "Harness file path is invalid.",
+            statusCode: 400,
+            hint: filePath
+        });
+    }
+    const normalized = path.posix.normalize(filePath).replace(/^\.\//, "");
+    if (normalized === "." || normalized.startsWith("../")) {
+        throw new VcmError({
+            code: "HARNESS_FILE_PATH_INVALID",
+            message: "Harness file path must stay inside the repository.",
+            statusCode: 400,
+            hint: filePath
+        });
+    }
+    return normalized;
+}
+function isProjectEditableHarnessFile(definition) {
+    return definition.ownership !== "whole-file" && definition.ownership !== "raw-file";
+}
+function getReadonlyHarnessReason(definition) {
+    if (definition.path === CLAUDE_SETTINGS_PATH) {
+        return "Claude Code hooks are generated by VCM fixed harness install.";
+    }
+    if (definition.ownership === "whole-file" || definition.ownership === "raw-file") {
+        return "This file is VCM-owned whole-file template content. Use fixed harness update instead.";
+    }
+    return "This harness file is not editable from Harness Studio.";
+}
+function assertManagedBlockUnchanged(definition, currentContent, nextContent) {
+    const currentBlock = extractManagedBlock(definition, currentContent);
+    const nextBlock = extractManagedBlock(definition, nextContent);
+    if (currentBlock && nextBlock !== currentBlock) {
+        throw new VcmError({
+            code: "HARNESS_MANAGED_BLOCK_PROTECTED",
+            message: "VCM fixed managed blocks cannot be edited from Harness Studio.",
+            statusCode: 409,
+            hint: "Edit project-specific content outside the VCM:BEGIN / VCM:END block, or use fixed harness update."
+        });
+    }
+    if (!currentBlock && nextBlock) {
+        throw new VcmError({
+            code: "HARNESS_MANAGED_BLOCK_PROTECTED",
+            message: "VCM fixed managed blocks must be installed by VCM.",
+            statusCode: 409,
+            hint: "Use fixed harness update instead of adding a VCM managed block manually."
+        });
+    }
+}
+function extractManagedBlock(definition, content) {
+    if (definition.ownership === "whole-file" || definition.ownership === "raw-file") {
+        return undefined;
+    }
+    return content.match(getManagedBlockPattern(definition))?.[0];
+}
 async function analyzeHarnessFiles(fs, repoRoot) {
     const analyses = [];
     for (const definition of HARNESS_FILES) {
@@ -508,7 +737,7 @@ async function removeLegacyCodexHarnessPaths(fs, repoRoot) {
     }
     return changes;
 }
-function renderHarnessStatus(analyses, legacyChanges = []) {
+function renderHarnessStatus(harnessRevision, analyses, legacyChanges = []) {
     const files = analyses.map((analysis) => analysis.status);
     const plannedChanges = analyses
         .map((analysis) => analysis.plannedChange)
@@ -528,6 +757,7 @@ function renderHarnessStatus(analyses, legacyChanges = []) {
             analysis.status.exists));
     return {
         version: VCM_HARNESS_VERSION,
+        harnessRevision,
         initialized,
         files,
         needsApply: plannedChanges.length > 0,
@@ -537,6 +767,9 @@ function renderHarnessStatus(analyses, legacyChanges = []) {
             : []
     };
 }
+async function readHarnessRevisionValue(fs, repoRoot) {
+    return (await readHarnessRevisionState(fs, repoRoot)).revision;
+}
 function renderManagedBlock(definition, rules) {
     const endSpacing = definition.blankLineBeforeEnd ? "\n\n" : "\n";
     if (definition.commentStyle === "hash") {
@@ -693,26 +926,28 @@ async function getHarnessBootstrapStatus(deps, repoRoot, now) {
         await checkModuleArchitectureDocs(deps.fs, repoRoot, moduleIndex),
         await checkFilledMarkdown(deps.fs, repoRoot, "docs/TESTING.md", "Testing doc", "testing-doc")
     ];
-    const session = await getCurrentHarnessBootstrapSession(deps, repoRoot, now);
+    const runState = await loadPersistedHarnessBootstrapRunState(deps.fs, repoRoot);
+    const session = await getCurrentHarnessEngineerBootstrapSession(deps, repoRoot);
     const fixedHarnessReady = checks[0]?.status === "ok";
     const projectChecks = checks.slice(1);
     const projectComplete = projectChecks.every((check) => check.status === "ok");
     const projectStarted = projectChecks.some((check) => check.status === "ok" || check.status === "incomplete");
+    const runActive = runState?.status === "running" && session?.status === "running";
     const status = !fixedHarnessReady
         ? "not_ready"
-        : session?.status === "running"
+        : runActive
             ? "running"
-            : projectComplete
+            : runState?.status === "complete" || projectComplete
                 ? "complete"
                 : projectStarted
                     ? "incomplete"
                     : "not_started";
     return {
         status,
-        canStart: fixedHarnessReady && session?.status !== "running",
+        canStart: fixedHarnessReady && !runActive,
         checks,
         session,
-        warnings: bootstrapWarnings(status, checks, session)
+        warnings: bootstrapWarnings(status, checks, session, runState)
     };
 }
 async function checkFixedHarness(fs, repoRoot) {
@@ -913,68 +1148,47 @@ function isFilledMarkdown(content) {
         .filter((line) => line && !line.startsWith("#"));
     return meaningfulLines.join("\n").length >= 120;
 }
-async function getCurrentHarnessBootstrapSession(deps, repoRoot, now) {
-    const persisted = await loadPersistedHarnessBootstrapSession(deps.fs, repoRoot);
-    const runtimeSession = deps.runtime
-        ?.listSessions(BOOTSTRAP_TASK_SLUG)
-        .find((session) => session.id === persisted?.id || session.status === "running");
-    if (runtimeSession) {
-        const session = {
-            id: runtimeSession.id,
-            claudeSessionId: persisted?.claudeSessionId ?? runtimeSession.id,
-            status: runtimeSession.status === "crashed" ? "crashed" : runtimeSession.status === "exited" ? "exited" : "running",
-            command: persisted?.command ?? "claude",
-            cwd: persisted?.cwd ?? repoRoot,
-            logPath: persisted?.logPath ?? BOOTSTRAP_LOG_PATH,
-            startedAt: runtimeSession.startedAt,
-            updatedAt: now(),
-            lastOutputAt: runtimeSession.lastOutputAt,
-            exitCode: runtimeSession.exitCode
-        };
-        await persistHarnessBootstrapSession(deps.fs, repoRoot, session);
-        return session;
-    }
-    if (persisted?.status === "running") {
-        return {
-            ...persisted,
-            status: "resumable",
-            updatedAt: now()
-        };
-    }
-    return undefined;
-}
-async function loadPersistedHarnessBootstrapSession(fs, repoRoot) {
+async function loadPersistedHarnessBootstrapRunState(fs, repoRoot) {
     const payload = await readOptionalJsonObject(fs, repoRoot, BOOTSTRAP_SESSION_PATH);
     if (!payload) {
         return undefined;
     }
-    if (typeof payload.id !== "string" ||
-        typeof payload.claudeSessionId !== "string" ||
-        typeof payload.command !== "string" ||
-        typeof payload.cwd !== "string" ||
-        typeof payload.logPath !== "string" ||
+    if (payload.version !== 1 ||
         typeof payload.updatedAt !== "string") {
         return undefined;
     }
     const status = payload.status;
-    if (status !== "running" && status !== "exited" && status !== "crashed" && status !== "resumable") {
+    if (status !== "running" && status !== "complete") {
         return undefined;
     }
     return {
-        id: payload.id,
-        claudeSessionId: payload.claudeSessionId,
+        version: 1,
         status,
-        command: payload.command,
-        cwd: payload.cwd,
-        logPath: payload.logPath,
+        sessionId: typeof payload.sessionId === "string" ? payload.sessionId : undefined,
+        claudeSessionId: typeof payload.claudeSessionId === "string" ? payload.claudeSessionId : undefined,
         startedAt: typeof payload.startedAt === "string" ? payload.startedAt : undefined,
+        completedAt: typeof payload.completedAt === "string" ? payload.completedAt : undefined,
         updatedAt: payload.updatedAt,
-        lastOutputAt: typeof payload.lastOutputAt === "string" ? payload.lastOutputAt : undefined,
-        exitCode: typeof payload.exitCode === "number" || payload.exitCode === null ? payload.exitCode : undefined
+        lastHookEvent: isHarnessBootstrapHookEvent(payload.lastHookEvent) ? payload.lastHookEvent : undefined
     };
 }
-async function persistHarnessBootstrapSession(fs, repoRoot, session) {
-    await fs.writeJsonAtomic(resolveHarnessPath(repoRoot, BOOTSTRAP_SESSION_PATH), session);
+async function persistHarnessBootstrapRunState(fs, repoRoot, state) {
+    await fs.writeJsonAtomic(resolveHarnessPath(repoRoot, BOOTSTRAP_SESSION_PATH), state);
+}
+async function clearHarnessBootstrapRunState(fs, repoRoot) {
+    await fs.removePath?.(resolveHarnessPath(repoRoot, BOOTSTRAP_SESSION_PATH), { force: true });
+}
+function isHarnessBootstrapHookEvent(value) {
+    return value === "Stop" || value === "StopFailure" || value === "UserPromptSubmit" || value === "PostCompact";
+}
+function matchesBootstrapRunState(state, input) {
+    if (state.sessionId && input.sessionId && state.sessionId !== input.sessionId) {
+        return false;
+    }
+    if (state.claudeSessionId && input.claudeSessionId && state.claudeSessionId !== input.claudeSessionId) {
+        return false;
+    }
+    return true;
 }
 async function readOptionalText(fs, repoRoot, relativePath) {
     const absolutePath = resolveHarnessPath(repoRoot, relativePath);
@@ -998,13 +1212,16 @@ async function readOptionalJsonObject(fs, repoRoot, relativePath) {
         return undefined;
     }
 }
-function bootstrapWarnings(status, checks, session) {
+function bootstrapWarnings(status, checks, session, runState) {
     const warnings = [];
     if (status === "not_ready") {
         warnings.push("Install or update the fixed VCM harness before running harness bootstrap.");
     }
     if (session?.status === "resumable") {
-        warnings.push("The previous bootstrap terminal is no longer active; start bootstrap again or finish the remaining files manually.");
+        warnings.push("The Harness Engineer session is resumable; resume it before running harness bootstrap.");
+    }
+    if (runState?.status === "running" && session?.status !== "running") {
+        warnings.push("The previous bootstrap run did not finish with an active Harness Engineer session; resume the session or run bootstrap again.");
     }
     const unknownChecks = checks.filter((check) => check.status === "unknown");
     if (unknownChecks.length > 0) {
@@ -1012,17 +1229,6 @@ function bootstrapWarnings(status, checks, session) {
     }
     return warnings;
 }
-function buildClaudeStartCommand(command = "claude", permissionMode = "default", claudeSessionId) {
-    const args = ["--session-id", claudeSessionId];
-    if (permissionMode === "bypassPermissions") {
-        args.push("--permission-mode", "bypassPermissions");
-    }
-    return {
-        command,
-        args,
-        display: `${command} ${args.join(" ")}`
-    };
-}
 function buildHarnessBootstrapPrompt(repoRoot) {
     return `Use the vcm-harness-bootstrap skill to finish the VCM harness bootstrap for this repository.