vibe-coding-master 0.3.32 → 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/api/harness-routes.js

@@ -16,6 +16,21 @@ export function registerHarnessRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.harnessService.applyHarness(project.repoRoot);
     });
+    app.get("/api/projects/harness/file", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.harnessService.getHarnessFileContent(project.repoRoot, request.query.path ?? "");
+    });
+    app.put("/api/projects/harness/file", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        if (typeof request.body?.content !== "string") {
+            throw new VcmError({
+                code: "HARNESS_FILE_CONTENT_INVALID",
+                message: "Harness file content must be a string.",
+                statusCode: 400
+            });
+        }
+        return deps.harnessService.updateHarnessFileContent(project.repoRoot, request.query.path ?? "", request.body.content);
+    });
     app.post("/api/projects/harness/tasks/:taskSlug/commit-and-rebase", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
@@ -42,10 +57,51 @@ export function registerHarnessRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.harnessService.startHarnessBootstrap(project.repoRoot, request.body ?? {});
     });
+    app.post("/api/projects/harness/bootstrap/restart", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.harnessService.restartHarnessBootstrap(project.repoRoot, request.body ?? {});
+    });
+    app.post("/api/projects/harness/bootstrap/stop", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.harnessService.stopHarnessBootstrap(project.repoRoot);
+    });
+    app.post("/api/projects/harness/bootstrap/run", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.harnessService.runHarnessBootstrap(project.repoRoot);
+    });
+    app.get("/api/projects/harness/engineer/session", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return (await deps.sessionService.getProjectHarnessEngineerSession(project.repoRoot)) ?? null;
+    });
+    app.post("/api/projects/harness/engineer/session/ensure", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.ensureProjectHarnessEngineerSession(project.repoRoot, request.body);
+    });
+    app.post("/api/projects/harness/engineer/session/start", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.startProjectHarnessEngineerSession(project.repoRoot, request.body);
+    });
+    app.post("/api/projects/harness/engineer/session/resume", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.resumeProjectHarnessEngineerSession(project.repoRoot, request.body);
+    });
+    app.post("/api/projects/harness/engineer/session/restart", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.restartProjectHarnessEngineerSession(project.repoRoot, request.body);
+    });
+    app.post("/api/projects/harness/engineer/session/stop", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.stopProjectHarnessEngineerSession(project.repoRoot);
+    });
+    app.post("/api/projects/harness/engineer/session/notify-harness", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.notifyProjectHarnessEngineerHarnessUpdated(project.repoRoot);
+    });
 }
 function degradedHarnessStatus(error) {
     return {
         version: 1,
+        harnessRevision: 0,
         initialized: false,
         files: [],
         needsApply: false,

package/dist/backend/api/session-routes.js

@@ -33,6 +33,11 @@ export function registerSessionRoutes(app, deps) {
         const role = parseRole(request.params.role);
         return deps.sessionService.resumeRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
     });
+    app.post("/api/tasks/:taskSlug/sessions/:role/notify-harness", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        return deps.sessionService.notifyRoleHarnessUpdated(project.repoRoot, request.params.taskSlug, role);
+    });
     app.post("/api/tasks/:taskSlug/sessions/:role/dispatch", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         if (!isDispatchableRole(request.params.role)) {

package/dist/backend/api/translation-routes.js

@@ -52,6 +52,10 @@ export function registerTranslationRoutes(app, deps) {
         await deps.translationService.stopSession(request.params.sessionId);
         return { ok: true };
     });
+    app.post("/api/projects/translation/session/notify-harness", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.notifyProjectTranslatorHarnessUpdated(project.repoRoot);
+    });
     app.post("/api/translation/sessions/:sessionId/retry/:translationId", async (request) => {
         await requireCurrentProject(deps.projectService);
         return deps.translationService.retryTranslation(request.params.sessionId, request.params.translationId);

package/dist/backend/cli/install-vcm-harness.js

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 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";
@@ -59,6 +60,9 @@ const AGENT_FRONTMATTER = {
     },
     translator: {
         description: "VCM project translation tool role for conversation translation, file translation, bootstrap, and memory updates."
+    },
+    "harness-engineer": {
+        description: "VCM project-scoped harness maintenance role for harness diagnosis, diff proposals, and VCM issue drafts."
     }
 };
 const MANAGED_FILES = [
@@ -132,6 +136,14 @@ const MANAGED_FILES = [
         commentStyle: "html",
         category: "agent-translator",
         content: renderTranslatorAgentRules()
+    },
+    {
+        path: ".claude/agents/harness-engineer.md",
+        title: "Harness Engineer Agent",
+        agentName: "harness-engineer",
+        commentStyle: "html",
+        category: "agent-harness-engineer",
+        content: renderHarnessEngineerHarnessRules()
     }
 ];
 const DURABLE_DOC_TEMPLATES = [

package/dist/backend/server.js

@@ -79,6 +79,7 @@ export async function createServer(deps, options = {}) {
     registerHarnessRoutes(app, {
         projectService: deps.projectService,
         harnessService: deps.harnessService,
+        sessionService: deps.sessionService,
         taskService: deps.taskService
     });
     registerTaskRoutes(app, {
@@ -114,6 +115,7 @@ export async function createServer(deps, options = {}) {
     registerTranslationRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
+        sessionService: deps.sessionService,
         translationService: deps.translationService
     });
     registerGatewayRoutes(app, { gatewayService: deps.gatewayService });
@@ -165,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,
@@ -184,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,
@@ -262,6 +263,7 @@ export function createDefaultServerDeps(options = {}) {
         translationService,
         appSettings,
         runtime,
+        harnessService,
         gatewayService,
         jobGuard: createJobGuardService(),
         translationWorkerService

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

@@ -1,4 +1,4 @@
-import { isGateReviewerRoleName, isTranslatorToolRoleName, isVcmRoleName } from "../../shared/constants.js";
+import { isGateReviewerRoleName, isHarnessEngineerToolRoleName, isTranslatorToolRoleName, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
@@ -44,6 +44,17 @@ export function createClaudeHookService(deps) {
         }
         return { project };
     }
+    async function getProjectToolHookContext(toolLabel) {
+        const project = await deps.projectService.getCurrentProject();
+        if (!project) {
+            throw new VcmError({
+                code: "PROJECT_NOT_CONNECTED",
+                message: `Connect a repository before accepting ${toolLabel} hooks.`,
+                statusCode: 409
+            });
+        }
+        return { project };
+    }
     async function processTranslatorHook(input) {
         const eventName = parseHookEvent(input.event.hook_event_name);
         const context = await getTranslatorHookContext();
@@ -63,6 +74,29 @@ export function createClaudeHookService(deps) {
             dispatchedCount: 0
         };
     }
+    async function processHarnessEngineerHook(input) {
+        const eventName = parseHookEvent(input.event.hook_event_name);
+        const context = await getProjectToolHookContext("Harness Engineer");
+        const session = await deps.sessionService.recordProjectHarnessEngineerHookEvent(context.project.repoRoot, {
+            eventName,
+            sessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd)
+        });
+        await deps.harnessService?.recordHarnessBootstrapHook(context.project.repoRoot, {
+            eventName,
+            sessionId: session?.id,
+            claudeSessionId: stringOrUndefined(input.event.session_id)
+        });
+        return {
+            ok: true,
+            eventName,
+            taskSlug: input.taskSlug,
+            role: input.role,
+            sessionUpdated: Boolean(session),
+            dispatchedCount: 0
+        };
+    }
     async function resolveHookTaskSlug(repoRoot, input) {
         if (!isGateReviewerRoleName(input.role)) {
             return input.taskSlug;
@@ -337,7 +371,7 @@ export function createClaudeHookService(deps) {
     }
     async function handlePermissionRequestHook(input) {
         if (!isVcmRoleName(input.role)) {
-            if (isTranslatorToolRoleName(input.role)) {
+            if (isTranslatorToolRoleName(input.role) || isHarnessEngineerToolRoleName(input.role)) {
                 const preferences = await deps.appSettings.getPreferences();
                 if (preferences.permissionRequestMode !== "allowAll") {
                     return undefined;
@@ -384,6 +418,9 @@ export function createClaudeHookService(deps) {
             if (isTranslatorToolRoleName(input.role)) {
                 return processTranslatorHook(input);
             }
+            if (isHarnessEngineerToolRoleName(input.role)) {
+                return processHarnessEngineerHook(input);
+            }
             const eventName = parseHookEvent(input.event.hook_event_name);
             if (eventName === "UserPromptSubmit") {
                 return handleUserPromptSubmitHook(input);
@@ -402,6 +439,9 @@ export function createClaudeHookService(deps) {
             if (isTranslatorToolRoleName(input.role)) {
                 return processTranslatorHook(input);
             }
+            if (isHarnessEngineerToolRoleName(input.role)) {
+                return processHarnessEngineerHook(input);
+            }
             return processStopHook(input, { allowBlock: true });
         },
         handlePermissionRequestHook

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

@@ -0,0 +1,32 @@
+import { resolveRepoPath } from "../adapters/filesystem.js";
+const HARNESS_REVISION_PATH = ".ai/vcm/harness/revision.json";
+export async function readHarnessRevisionState(fs, repoRoot) {
+    const revisionPath = resolveRepoPath(repoRoot, HARNESS_REVISION_PATH);
+    if (!await fs.pathExists(revisionPath)) {
+        return {
+            version: 1,
+            revision: 0
+        };
+    }
+    const payload = await fs.readJson(revisionPath);
+    return {
+        version: 1,
+        revision: normalizeRevision(payload.revision),
+        updatedAt: typeof payload.updatedAt === "string" ? payload.updatedAt : undefined
+    };
+}
+export async function bumpHarnessRevision(fs, repoRoot, updatedAt) {
+    const current = await readHarnessRevisionState(fs, repoRoot);
+    const next = {
+        version: 1,
+        revision: current.revision + 1,
+        updatedAt
+    };
+    await fs.writeJsonAtomic(resolveRepoPath(repoRoot, HARNESS_REVISION_PATH), next);
+    return next;
+}
+function normalizeRevision(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0
+        ? value
+        : 0;
+}