vibe-coding-master 0.4.0 → 0.4.1

package/README.md

@@ -486,7 +486,7 @@ For `.gitignore`, VCM uses a gitignore-native managed block:
 
 VCM also JSON-merges `.claude/settings.json` to install Claude Code `PreToolUse`, `UserPromptSubmit`, `Stop`, and `PermissionRequest` hooks plus a managed `env.BASH_DEFAULT_TIMEOUT_MS` so foreground watch windows fit inside the Bash tool timeout. The hooks post directly to the local VCM backend, so roles do not need a VCM CLI command to confirm delivery or report turn completion. The `Stop` hook forwards the backend response to Claude Code, which lets VCM block turn-end while a validation job is still running.
 
-Bootstrap is AI-assisted. VCM starts a visible temporary Claude Code session in the connected repository and asks it to use the `vcm-harness-bootstrap` skill. Bootstrap fills project-specific content and generated context:
+Bootstrap is AI-assisted. VCM starts or resumes the project-scoped Harness Engineer Claude Code session in the connected repository and asks it to use the `vcm-harness-bootstrap` skill. Bootstrap fills project-specific content and generated context:
 
 ```text
 CLAUDE.md project context outside the VCM managed block

package/dist/backend/server.js

@@ -167,14 +167,6 @@ export function createDefaultServerDeps(options = {}) {
     const registry = createSessionRegistry();
     const artifactService = createArtifactService(fs);
     const projectService = createProjectService({ fs, git, appSettings });
-    const harnessService = createHarnessService({
-        fs,
-        git,
-        runtime,
-        projectService,
-        apiUrl: options.apiUrl,
-        runFixedInstaller: createScriptFixedHarnessInstaller(path.join(getAppRoot(), "scripts/install-vcm-harness.mjs"))
-    });
     const taskService = createTaskService({ fs, git, artifactService, projectService });
     const sessionService = createSessionService({
         fs,
@@ -186,6 +178,13 @@ export function createDefaultServerDeps(options = {}) {
         taskService,
         apiUrl: options.apiUrl
     });
+    const harnessService = createHarnessService({
+        fs,
+        git,
+        runtime,
+        harnessEngineerSessions: sessionService,
+        runFixedInstaller: createScriptFixedHarnessInstaller(path.join(getAppRoot(), "scripts/install-vcm-harness.mjs"))
+    });
     const commandDispatcher = createCommandDispatcher({
         runtime,
         sessionService,
@@ -264,6 +263,7 @@ export function createDefaultServerDeps(options = {}) {
         translationService,
         appSettings,
         runtime,
+        harnessService,
         gatewayService,
         jobGuard: createJobGuardService(),
         translationWorkerService

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

@@ -83,6 +83,11 @@ export function createClaudeHookService(deps) {
             transcriptPath: stringOrUndefined(input.event.transcript_path),
             cwd: stringOrUndefined(input.event.cwd)
         });
+        await deps.harnessService?.recordHarnessBootstrapHook(context.project.repoRoot, {
+            eventName,
+            sessionId: session?.id,
+            claudeSessionId: stringOrUndefined(input.event.session_id)
+        });
         return {
             ok: true,
             eventName,

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

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
 import path from "node:path";
 import { promisify } from "node:util";
@@ -19,10 +18,8 @@ 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;
@@ -307,7 +304,7 @@ export function createHarnessService(deps) {
             return getHarnessBootstrapStatus(deps, repoRoot, now);
         },
         async startHarnessBootstrap(repoRoot, input = {}) {
-            const session = await launchHarnessBootstrapSession(deps, repoRoot, now, input, { forceFresh: false });
+            const session = await ensureHarnessEngineerForBootstrap(deps, repoRoot, now, input);
             const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
             return {
                 status: {
@@ -319,11 +316,7 @@ export function createHarnessService(deps) {
             };
         },
         async restartHarnessBootstrap(repoRoot, input = {}) {
-            const existing = await getCurrentHarnessBootstrapSession(deps, repoRoot, now);
-            if (existing && deps.runtime?.getSession(existing.id)) {
-                await deps.runtime.stop(existing.id);
-            }
-            const session = await launchHarnessBootstrapSession(deps, repoRoot, now, input, { forceFresh: true });
+            const session = await restartHarnessEngineerForBootstrap(deps, repoRoot, now, input);
             const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
             return {
                 status: {
@@ -335,26 +328,20 @@ export function createHarnessService(deps) {
             };
         },
         async stopHarnessBootstrap(repoRoot) {
-            const existing = await getCurrentHarnessBootstrapSession(deps, repoRoot, now);
+            const existing = await getCurrentHarnessEngineerBootstrapSession(deps, repoRoot);
             if (!existing) {
                 throw new VcmError({
                     code: "HARNESS_BOOTSTRAP_SESSION_MISSING",
-                    message: "Harness bootstrap terminal has not been started.",
+                    message: "Harness Engineer session has not been started.",
                     statusCode: 404
                 });
             }
-            if (deps.runtime?.getSession(existing.id)) {
-                await deps.runtime.stop(existing.id);
-            }
-            await persistHarnessBootstrapSession(deps.fs, repoRoot, {
-                ...existing,
-                status: "exited",
-                updatedAt: now()
-            });
+            await deps.harnessEngineerSessions?.stopProjectHarnessEngineerSession(repoRoot);
+            await clearHarnessBootstrapRunState(deps.fs, repoRoot);
             return getHarnessBootstrapStatus(deps, repoRoot, now);
         },
         async runHarnessBootstrap(repoRoot) {
-            if (!deps.runtime) {
+            if (!deps.runtime || !deps.harnessEngineerSessions) {
                 throw new VcmError({
                     code: "HARNESS_BOOTSTRAP_UNAVAILABLE",
                     message: "Harness bootstrap sessions are not available in this VCM runtime.",
@@ -366,11 +353,20 @@ export function createHarnessService(deps) {
             if (!session || session.status !== "running" || !deps.runtime.getSession(session.id)) {
                 throw new VcmError({
                     code: "HARNESS_BOOTSTRAP_SESSION_NOT_RUNNING",
-                    message: "Start the Harness Bootstrap terminal before running bootstrap.",
+                    message: "Start the Harness Engineer session before running bootstrap.",
                     statusCode: 409
                 });
             }
             const prompt = buildHarnessBootstrapPrompt(repoRoot);
+            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 {
@@ -381,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);
         }
     };
 }
@@ -400,8 +411,8 @@ function dedupeHarnessChanges(changedFiles) {
     }
     return changes;
 }
-async function launchHarnessBootstrapSession(deps, repoRoot, now, input, options) {
-    if (!deps.runtime || !deps.projectService) {
+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.",
@@ -409,56 +420,62 @@ async function launchHarnessBootstrapSession(deps, repoRoot, now, input, options
         });
     }
     const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
-    if (!options.forceFresh && currentStatus.session?.status === "running") {
+    if (currentStatus.session?.status === "running") {
         return currentStatus.session;
     }
-    if (!currentStatus.canStart && !(options.forceFresh && currentStatus.session?.status === "running")) {
+    if (!currentStatus.canStart) {
         throw new VcmError({
             code: "HARNESS_BOOTSTRAP_NOT_READY",
             message: "Install the fixed VCM harness before starting harness bootstrap.",
             statusCode: 409
         });
     }
-    const config = await deps.projectService.loadConfig(repoRoot);
-    const claudeSessionId = randomUUID();
-    const permissionMode = normalizeClaudePermissionMode(input.permissionMode);
-    const model = normalizeClaudeModel(input.model);
-    const effort = normalizeClaudeEffort(input.effort);
-    const command = buildClaudeStartCommand(config.claudeCommand, permissionMode, claudeSessionId, model, effort);
-    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 session = {
-        id: runtimeSession.id,
-        claudeSessionId,
-        status: runtimeSession.status === "crashed" ? "crashed" : runtimeSession.status === "exited" ? "exited" : "running",
-        command: command.display,
-        permissionMode,
-        model,
-        effort,
-        cwd: repoRoot,
-        logPath: BOOTSTRAP_LOG_PATH,
-        startedAt: runtimeSession.startedAt,
-        updatedAt: now(),
-        lastOutputAt: runtimeSession.lastOutputAt,
-        exitCode: runtimeSession.exitCode
+    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
     };
-    await persistHarnessBootstrapSession(deps.fs, repoRoot, session);
-    return session;
+}
+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)) {
@@ -909,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) {
@@ -1129,74 +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",
-            permissionMode: persisted?.permissionMode,
-            model: persisted?.model,
-            effort: persisted?.effort,
-            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,
-        permissionMode: normalizeClaudePermissionMode(payload.permissionMode),
-        model: normalizeClaudeModel(payload.model),
-        effort: normalizeClaudeEffort(payload.effort),
-        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);
@@ -1220,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) {
@@ -1234,56 +1229,6 @@ function bootstrapWarnings(status, checks, session) {
     }
     return warnings;
 }
-function buildClaudeStartCommand(command = "claude", permissionMode = "default", claudeSessionId, model = "default", effort = "default") {
-    const args = ["--session-id", claudeSessionId, "--model", model];
-    if (effort === "ultracode") {
-        args.push("--settings", JSON.stringify({ ultracode: true }));
-    }
-    else if (effort !== "default") {
-        args.push("--effort", effort);
-    }
-    if (permissionMode === "bypassPermissions") {
-        args.push("--permission-mode", "bypassPermissions");
-    }
-    return {
-        command,
-        args,
-        display: [command, ...args].map(formatDisplayArg).join(" ")
-    };
-}
-function formatDisplayArg(value) {
-    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) {
-        return value;
-    }
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
-function normalizeClaudePermissionMode(value) {
-    return value === "bypassPermissions" || value === "dangerously-skip-permissions"
-        ? "bypassPermissions"
-        : "default";
-}
-function normalizeClaudeModel(value) {
-    if (value === "best"
-        || value === "fable"
-        || value === "opus"
-        || value === "opus[1m]"
-        || value === "claude-opus-4-8"
-        || value === "claude-opus-4-8[1m]") {
-        return value;
-    }
-    return "default";
-}
-function normalizeClaudeEffort(value) {
-    if (value === "low"
-        || value === "medium"
-        || value === "high"
-        || value === "xhigh"
-        || value === "max"
-        || value === "ultracode") {
-        return value;
-    }
-    return "default";
-}
 function buildHarnessBootstrapPrompt(repoRoot) {
     return `Use the vcm-harness-bootstrap skill to finish the VCM harness bootstrap for this repository.