vibe-coding-master 0.3.31 → 0.4.0

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/runtime/node-pty-runtime.js

@@ -44,6 +44,7 @@ export function createNodePtyTerminalRuntime(deps) {
             process: child,
             listeners: new Set(),
             logWriter,
+            replayBuffer: "",
             disposed: false
         };
         entries.set(session.id, entry);
@@ -52,6 +53,7 @@ export function createNodePtyTerminalRuntime(deps) {
                 return;
             }
             entry.session.lastOutputAt = now();
+            entry.replayBuffer = appendTerminalReplay(entry.replayBuffer, data);
             entry.logWriter.append(data);
             emit(entry, {
                 sessionId: session.id,
@@ -138,7 +140,18 @@ export function createNodePtyTerminalRuntime(deps) {
         subscribe(sessionId, listener, options = {}) {
             const entry = getEntry(entries, sessionId);
             entry.listeners.add(listener);
-            if (options.replay !== false && entry.input.logPath) {
+            if (options.replay !== false && entry.replayBuffer) {
+                listener({
+                    id: `evt_${Date.now()}_${Math.random().toString(16).slice(2)}`,
+                    sessionId,
+                    taskSlug: entry.session.taskSlug,
+                    role: entry.session.role,
+                    type: "output",
+                    timestamp: now(),
+                    data: entry.replayBuffer
+                });
+            }
+            else if (options.replay !== false && entry.input.logPath) {
                 void readTerminalReplayText(deps.fs, entry.input.logPath)
                     .then((data) => {
                     if (!data || !entry.listeners.has(listener)) {
@@ -228,6 +241,12 @@ export function tailTerminalReplay(data, limitBytes = TERMINAL_REPLAY_TAIL_LIMIT
     const firstLineBreak = tail.indexOf("\n");
     return firstLineBreak >= 0 ? tail.slice(firstLineBreak + 1) : tail;
 }
+export function appendTerminalReplay(current, data, limitBytes = TERMINAL_REPLAY_TAIL_LIMIT_BYTES) {
+    if (!data) {
+        return current;
+    }
+    return tailTerminalReplay(`${current}${data}`, limitBytes);
+}
 export function buildPtyEnvironment(baseEnv, inputEnv = {}) {
     const env = {
         ...baseEnv,

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 });

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,24 @@ 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)
+        });
+        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 +366,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 +413,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 +434,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;
+}