vibe-coding-master 0.3.32 → 0.4.0

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

@@ -5,6 +5,7 @@ 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,6 +17,7 @@ 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";
@@ -119,6 +121,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 +171,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 +225,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 +307,71 @@ export function createHarnessService(deps) {
             return getHarnessBootstrapStatus(deps, repoRoot, now);
         },
         async startHarnessBootstrap(repoRoot, input = {}) {
-            if (!deps.runtime || !deps.projectService) {
+            const session = await launchHarnessBootstrapSession(deps, repoRoot, now, input, { forceFresh: false });
+            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
+            return {
+                status: {
+                    ...nextStatus,
+                    session
+                },
+                session,
+                prompt: buildHarnessBootstrapPrompt(repoRoot)
+            };
+        },
+        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 nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
+            return {
+                status: {
+                    ...nextStatus,
+                    session
+                },
+                session,
+                prompt: buildHarnessBootstrapPrompt(repoRoot)
+            };
+        },
+        async stopHarnessBootstrap(repoRoot) {
+            const existing = await getCurrentHarnessBootstrapSession(deps, repoRoot, now);
+            if (!existing) {
+                throw new VcmError({
+                    code: "HARNESS_BOOTSTRAP_SESSION_MISSING",
+                    message: "Harness bootstrap terminal 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()
+            });
+            return getHarnessBootstrapStatus(deps, repoRoot, now);
+        },
+        async runHarnessBootstrap(repoRoot) {
+            if (!deps.runtime) {
                 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 Bootstrap terminal 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);
+            await submitTerminalInput(deps.runtime, session.id, prompt);
             const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, now);
             return {
                 status: {
@@ -346,6 +400,66 @@ function dedupeHarnessChanges(changedFiles) {
     }
     return changes;
 }
+async function launchHarnessBootstrapSession(deps, repoRoot, now, input, options) {
+    if (!deps.runtime || !deps.projectService) {
+        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 (!options.forceFresh && currentStatus.session?.status === "running") {
+        return currentStatus.session;
+    }
+    if (!currentStatus.canStart && !(options.forceFresh && currentStatus.session?.status === "running")) {
+        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
+    };
+    await persistHarnessBootstrapSession(deps.fs, repoRoot, session);
+    return session;
+}
 function normalizeHarnessGitPath(value) {
     if (!value || value.includes("\0") || path.posix.isAbsolute(value)) {
         throw new VcmError({
@@ -369,6 +483,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 +720,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 +740,7 @@ function renderHarnessStatus(analyses, legacyChanges = []) {
             analysis.status.exists));
     return {
         version: VCM_HARNESS_VERSION,
+        harnessRevision,
         initialized,
         files,
         needsApply: plannedChanges.length > 0,
@@ -537,6 +750,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") {
@@ -924,6 +1140,9 @@ async function getCurrentHarnessBootstrapSession(deps, repoRoot, now) {
             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,
@@ -965,6 +1184,9 @@ async function loadPersistedHarnessBootstrapSession(fs, repoRoot) {
         claudeSessionId: payload.claudeSessionId,
         status,
         command: payload.command,
+        permissionMode: normalizeClaudePermissionMode(payload.permissionMode),
+        model: normalizeClaudeModel(payload.model),
+        effort: normalizeClaudeEffort(payload.effort),
         cwd: payload.cwd,
         logPath: payload.logPath,
         startedAt: typeof payload.startedAt === "string" ? payload.startedAt : undefined,
@@ -1012,17 +1234,56 @@ function bootstrapWarnings(status, checks, session) {
     }
     return warnings;
 }
-function buildClaudeStartCommand(command = "claude", permissionMode = "default", claudeSessionId) {
-    const args = ["--session-id", claudeSessionId];
+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.join(" ")}`
+        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.