vibe-coding-master 0.3.0 → 0.3.2

package/dist/backend/services/codex-review-service.js

@@ -4,12 +4,16 @@ import { CODEX_REVIEW_GATES } from "../../shared/types/codex-review.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
+import { renderCodexConfigHarnessRules } from "../templates/harness/codex-review.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const CODEX_DIR = ".ai/codex";
 const CODEX_CONFIG_PATH = ".ai/codex/config.toml";
 const CODEX_REVIEW_DIR = ".ai/vcm/codex-reviews";
 const REQUESTS_DIR = ".ai/vcm/codex-reviews/requests";
 const CODEX_REVIEW_VERSION = 1;
+const CODEX_REVIEWER_ROLE = "codex-reviewer";
+const DEFAULT_REPORT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_REPORT_TIMEOUT_MS = 30 * 60 * 1000;
 const activeRuns = new Set();
 const SOURCE_ARTIFACTS = {
     "architecture-plan": [
@@ -29,6 +33,8 @@ const SOURCE_ARTIFACTS = {
 const VALID_SEVERITIES = new Set(["critical", "high", "medium", "low"]);
 export function createCodexReviewService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
+    const reportPollIntervalMs = deps.reportPollIntervalMs ?? DEFAULT_REPORT_POLL_INTERVAL_MS;
+    const reportTimeoutMs = deps.reportTimeoutMs ?? DEFAULT_REPORT_TIMEOUT_MS;
     async function getContext(repoRoot, taskSlug) {
         const projectConfig = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
@@ -153,9 +159,7 @@ export function createCodexReviewService(deps) {
             const codexDir = resolveRepoPath(context.taskRepoRoot, CODEX_DIR);
             const reviewDir = resolveRepoPath(context.taskRepoRoot, CODEX_REVIEW_DIR);
             const prompt = await buildCodexPrompt(deps.fs, context.taskRepoRoot, gate, requestId);
-            const outputMessagePath = path.join(reviewDir, "logs", `${requestId}.last-message.txt`);
             await deps.fs.ensureDir(reviewDir);
-            await deps.fs.ensureDir(path.dirname(outputMessagePath));
             if (!(await deps.fs.pathExists(codexDir))) {
                 throw new VcmError({
                     code: "CODEX_REVIEW_CONFIG_MISSING",
@@ -164,32 +168,13 @@ export function createCodexReviewService(deps) {
                     hint: "Apply the VCM harness before requesting Codex review gates."
                 });
             }
-            const args = buildCodexExecArgs({
-                codexDir,
-                reviewDir,
-                prompt,
-                outputMessagePath,
-                config: context.config
-            });
-            const result = await deps.runner.run(context.config.command, args, {
-                cwd: context.taskRepoRoot,
-                env: {
-                    ...process.env,
-                    VCM_TASK_REPO_ROOT: context.taskRepoRoot,
-                    VCM_TASK_SLUG: context.taskSlug,
-                    VCM_CODEX_REVIEW_GATE: gate,
-                    VCM_CODEX_REVIEW_REQUEST_ID: requestId
-                }
+            const session = await ensureCodexReviewerSession(context);
+            await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
+            await submitTerminalInput(deps.runtime, session.id, prompt);
+            const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), {
+                intervalMs: reportPollIntervalMs,
+                timeoutMs: reportTimeoutMs
             });
-            if (result.exitCode !== 0) {
-                throw new VcmError({
-                    code: "CODEX_REVIEW_FAILED",
-                    message: `Codex CLI exited with ${result.exitCode}.`,
-                    statusCode: 500,
-                    hint: trimCommandOutput(`${result.stderr}\n${result.stdout}`)
-                });
-            }
-            const parsed = await parseGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now());
             const completedAt = now();
             await updateGateRecord(context, gate, {
                 status: "completed",
@@ -230,6 +215,29 @@ export function createCodexReviewService(deps) {
             activeRuns.delete(runKey);
         }
     }
+    async function ensureCodexReviewerSession(context) {
+        const existing = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
+        if (existing?.status === "running" && deps.runtime.getSession(existing.id)) {
+            return existing;
+        }
+        if (existing?.claudeSessionId) {
+            try {
+                return await deps.sessionService.resumeRoleSession(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE, {
+                    cols: 100,
+                    rows: 28,
+                    model: "default"
+                });
+            }
+            catch {
+                // Fall through to a fresh Codex Reviewer terminal if the saved session cannot be resumed.
+            }
+        }
+        return deps.sessionService.startRoleSession(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE, {
+            cols: 100,
+            rows: 28,
+            model: "default"
+        });
+    }
     async function updateGateRecord(context, gate, patch, options = {}) {
         const index = await loadIndex(deps.fs, context, now());
         const next = applyGateState(index, gate, patch, now(), options.clearActiveGate);
@@ -276,6 +284,29 @@ export function createCodexReviewService(deps) {
             const context = await getContext(repoRoot, taskSlug);
             return loadIndex(deps.fs, context, now());
         },
+        async updateSettings(repoRoot, taskSlug, input) {
+            const context = await getContext(repoRoot, taskSlug);
+            const requiredGates = new Set(context.config.enabled ? context.config.requiredGates : []);
+            for (const [gate, enabled] of Object.entries(input?.gates ?? {})) {
+                if (!isCodexReviewGate(gate)) {
+                    continue;
+                }
+                if (enabled) {
+                    requiredGates.add(gate);
+                }
+                else {
+                    requiredGates.delete(gate);
+                }
+            }
+            await writeRuntimeConfigSettings(deps.fs, context.taskRepoRoot, [...requiredGates]);
+            const nextContext = await getContext(repoRoot, taskSlug);
+            const index = await loadIndex(deps.fs, nextContext, now());
+            await saveIndex(deps.fs, nextContext.taskRepoRoot, {
+                ...index,
+                updatedAt: now()
+            });
+            return loadIndex(deps.fs, nextContext, now());
+        },
         requestReviewGate(repoRoot, taskSlug, gate) {
             return requestReviewGateInternal(repoRoot, taskSlug, gate);
         },
@@ -356,12 +387,60 @@ async function loadRuntimeConfig(fs, taskRepoRoot) {
     const parsedGates = parseTomlStringArray(section, "required_gates").filter(isCodexReviewGate);
     return {
         enabled,
-        requiredGates: parsedGates.length > 0 ? parsedGates : [...CODEX_REVIEW_GATES],
+        requiredGates: parsedGates.length > 0 ? parsedGates : enabled ? [...CODEX_REVIEW_GATES] : [],
         model: parseTomlString(content, "model"),
         modelReasoningEffort: parseTomlString(content, "model_reasoning_effort"),
         command: parseTomlString(section, "command") ?? "codex"
     };
 }
+async function writeRuntimeConfigSettings(fs, taskRepoRoot, requiredGates) {
+    const configPath = resolveRepoPath(taskRepoRoot, CODEX_CONFIG_PATH);
+    const current = await fs.pathExists(configPath)
+        ? await fs.readText(configPath)
+        : renderCodexConfigHarnessRules();
+    const section = renderCodexReviewSettingsSection(requiredGates);
+    const next = replaceTomlSection(current, "vcm.codex_review", section);
+    await fs.writeText(configPath, next);
+}
+function renderCodexReviewSettingsSection(requiredGates) {
+    if (requiredGates.length === 0) {
+        return [
+            "[vcm.codex_review]",
+            "enabled = false",
+            "required_gates = []"
+        ].join("\n");
+    }
+    const lines = [
+        "[vcm.codex_review]",
+        "enabled = true",
+        "required_gates = [",
+        ...CODEX_REVIEW_GATES
+            .filter((gate) => requiredGates.includes(gate))
+            .map((gate) => `  "${gate}",`),
+        "]"
+    ];
+    return lines.join("\n");
+}
+function replaceTomlSection(content, sectionName, nextSection) {
+    const lines = content.replace(/\s+$/g, "").split(/\r?\n/);
+    const header = `[${sectionName}]`;
+    const start = lines.findIndex((line) => line.trim() === header);
+    if (start < 0) {
+        return `${lines.join("\n").trimEnd()}\n\n${nextSection}\n`;
+    }
+    let end = lines.length;
+    for (let index = start + 1; index < lines.length; index += 1) {
+        if (/^\s*\[[^\]]+\]\s*$/.test(lines[index])) {
+            end = index;
+            break;
+        }
+    }
+    return [
+        ...lines.slice(0, start),
+        nextSection,
+        ...lines.slice(end)
+    ].join("\n").trimEnd() + "\n";
+}
 async function loadIndex(fs, context, timestamp) {
     const indexPath = getIndexPath(context.taskRepoRoot);
     const raw = await readJsonOrNull(fs, indexPath);
@@ -444,6 +523,8 @@ async function computeInputHash(deps, taskRepoRoot, gate) {
         "CLAUDE.md",
         ".ai/codex/AGENTS.md",
         ".ai/codex/config.toml",
+        ".ai/codex/.codex/config.toml",
+        ".ai/codex/.codex/hooks.json",
         promptPathForGate(gate)
     ];
     for (const relativePath of [...common, ...SOURCE_ARTIFACTS[gate]]) {
@@ -456,7 +537,7 @@ async function computeInputHash(deps, taskRepoRoot, gate) {
             digest.update("<missing>");
         }
     }
-    if (gate === "final-diff") {
+    if (gate === "architecture-plan" || gate === "final-diff") {
         digest.update(await commandStdout(deps.runner, taskRepoRoot, ["status", "--porcelain=v1"]));
         digest.update(await commandStdout(deps.runner, taskRepoRoot, ["diff", "--binary"]));
         digest.update(await commandStdout(deps.runner, taskRepoRoot, ["diff", "--cached", "--binary"]));
@@ -497,31 +578,28 @@ Decision: approve|request_changes
 
 Write only that report file. Do not edit any other file.`;
 }
-function buildCodexExecArgs(input) {
-    const args = [
-        "exec",
-        "--cd",
-        input.codexDir,
-        "--add-dir",
-        input.reviewDir,
-        "--sandbox",
-        "workspace-write",
-        "--ask-for-approval",
-        "never",
-        "--skip-git-repo-check",
-        "--color",
-        "never",
-        "--output-last-message",
-        input.outputMessagePath
-    ];
-    if (input.config.model) {
-        args.push("--model", input.config.model);
-    }
-    if (input.config.modelReasoningEffort) {
-        args.push("--config", `model_reasoning_effort="${input.config.modelReasoningEffort}"`);
+async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, options) {
+    const startedAt = Date.now();
+    let lastError;
+    while (Date.now() - startedAt <= options.timeoutMs) {
+        try {
+            return await parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp);
+        }
+        catch (error) {
+            lastError = error;
+            if (!isPendingReportError(error)) {
+                throw error;
+            }
+        }
+        await delay(options.intervalMs);
     }
-    args.push(input.prompt);
-    return args;
+    const detail = errorMessage(lastError);
+    throw new VcmError({
+        code: "CODEX_REVIEW_REPORT_TIMEOUT",
+        message: `Codex Reviewer did not produce a valid ${gate} report within ${Math.round(options.timeoutMs / 1000)}s.`,
+        statusCode: 504,
+        hint: detail
+    });
 }
 async function parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp) {
     const reportPath = reportPathForGate(gate);
@@ -744,13 +822,6 @@ function renderProjectManagerCallback(input) {
     ];
     return lines.join("\n");
 }
-function trimCommandOutput(output) {
-    const trimmed = output.trim();
-    if (!trimmed) {
-        return undefined;
-    }
-    return trimmed.length > 4000 ? `${trimmed.slice(0, 4000)}...` : trimmed;
-}
 function errorMessage(error) {
     if (error instanceof VcmError) {
         return error.hint ? `${error.message} ${error.hint}` : error.message;
@@ -760,6 +831,20 @@ function errorMessage(error) {
     }
     return "Unknown Codex review error.";
 }
+function isPendingReportError(error) {
+    return error instanceof VcmError && [
+        "CODEX_REVIEW_DECISION_MISSING",
+        "CODEX_REVIEW_REPORT_GATE_MISMATCH",
+        "CODEX_REVIEW_REPORT_MISSING",
+        "CODEX_REVIEW_REPORT_STALE"
+    ].includes(error.code);
+}
+function delay(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function escapeRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }

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

@@ -4,7 +4,7 @@ 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 { renderCodexAgentsHarnessRules, renderCodexArchitecturePlanPrompt, renderCodexConfigHarnessRules, renderCodexFinalDiffPrompt, renderCodexReviewResultSchema, renderCodexValidationAdequacyPrompt, renderRequestCodexReviewTool, renderVcmCodexReviewGateSkillRules } from "../templates/harness/codex-review.js";
+import { renderCodexAgentsHarnessRules, renderCodexArchitecturePlanPrompt, renderCodexCliConfigHarnessRules, renderCodexConfigHarnessRules, renderCodexFinalDiffPrompt, renderCodexHooksHarnessRules, renderCodexReviewResultSchema, renderCodexValidationAdequacyPrompt, renderRequestCodexReviewTool, renderVcmCodexReviewGateSkillRules } from "../templates/harness/codex-review.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";
@@ -110,6 +110,20 @@ const HARNESS_FILES = [
         ownership: "raw-file",
         renderRules: renderCodexConfigHarnessRules
     },
+    {
+        kind: "codex-cli-config",
+        path: ".ai/codex/.codex/config.toml",
+        title: "VCM Codex CLI Config",
+        ownership: "raw-file",
+        renderRules: renderCodexCliConfigHarnessRules
+    },
+    {
+        kind: "codex-hooks",
+        path: ".ai/codex/.codex/hooks.json",
+        title: "VCM Codex Hooks",
+        ownership: "raw-file",
+        renderRules: renderCodexHooksHarnessRules
+    },
     {
         kind: "codex-prompt-architecture-plan",
         path: ".ai/codex/prompts/architecture-plan-gate.md",
@@ -393,8 +407,21 @@ function renderHarnessStatus(analyses) {
     const plannedChanges = analyses
         .map((analysis) => analysis.plannedChange)
         .filter((change) => Boolean(change));
+    // Derive `initialized`: the VCM harness is considered installed when at least one
+    // VCM-exclusive marker is present (per analysis):
+    //   - status.hasManagedBlock === true (a managed block already lives in the file), OR
+    //   - definition.ownership is "whole-file" | "raw-file" AND status.exists === true
+    //     (a VCM-owned file lives at a VCM-exclusive path).
+    // A pre-existing claude-settings (default "managed-block" ownership, no managed block)
+    // or a non-VCM CLAUDE.md/.gitignore (action "insert", hasManagedBlock === false) is
+    // intentionally NOT counted as initialized.
+    const initialized = analyses.some((analysis) => analysis.status.hasManagedBlock ||
+        ((analysis.definition.ownership === "whole-file" ||
+            analysis.definition.ownership === "raw-file") &&
+            analysis.status.exists));
     return {
         version: VCM_HARNESS_VERSION,
+        initialized,
         files,
         needsApply: plannedChanges.length > 0,
         plannedChanges,

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { ROLE_NAMES, isRoleName } from "../../shared/constants.js";
+import { VCM_ROLE_NAMES, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -282,8 +282,8 @@ async function listRouteFiles(fs, input) {
     return routeFiles;
 }
 function parseRouteFileName(fileName) {
-    for (const fromRole of ROLE_NAMES) {
-        for (const toRole of ROLE_NAMES) {
+    for (const fromRole of VCM_ROLE_NAMES) {
+        for (const toRole of VCM_ROLE_NAMES) {
             if (fromRole === toRole) {
                 continue;
             }
@@ -371,14 +371,14 @@ function selectDispatchCandidates(routeFiles, stoppedRole) {
     });
 }
 function validateMessagePolicy(fromRole, toRole, type) {
-    if (!ROLE_NAMES.includes(toRole)) {
+    if (!VCM_ROLE_NAMES.includes(toRole)) {
         throw new VcmError({
             code: "MESSAGE_TARGET_UNKNOWN",
             message: `Unknown target role: ${toRole}`,
             statusCode: 400
         });
     }
-    if (!isRoleName(String(fromRole))) {
+    if (!isVcmRoleName(String(fromRole))) {
         throw new VcmError({
             code: "MESSAGE_SENDER_UNKNOWN",
             message: `Unknown sender role: ${fromRole}`,
@@ -424,7 +424,8 @@ function getMessageDeliveryTime(message) {
     return message.deliveredAt ?? message.createdAt;
 }
 async function clearRouteFileIfStillMatchesMessage(fs, input, message) {
-    if (!message.routePath || !isRoleName(String(message.fromRole))) {
+    const fromRole = message.fromRole;
+    if (!message.routePath || !isVcmRoleName(fromRole)) {
         return;
     }
     const absolutePath = resolveRepoPath(input.taskRepoRoot ?? input.repoRoot, message.routePath);
@@ -432,7 +433,7 @@ async function clearRouteFileIfStillMatchesMessage(fs, input, message) {
         return;
     }
     const routeContent = await fs.readText(absolutePath);
-    const parsed = parseRouteFileContent(routeContent, message.fromRole, message.toRole);
+    const parsed = parseRouteFileContent(routeContent, fromRole, message.toRole);
     if (parsed.body.trim() === message.body.trim() &&
         parsed.type === message.type &&
         arraysEqual(parsed.artifactRefs, message.artifactRefs)) {

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

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { ROLE_NAMES } from "../../shared/constants.js";
+import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 const DEFAULT_HANDOFF_ROOT = ".ai/vcm/handoffs";
 const DEFAULT_STATE_ROOT = ".ai/vcm";
@@ -182,7 +182,7 @@ export function buildDefaultProjectConfig(repoRoot) {
     return {
         version: 1,
         repoRoot,
-        defaultRoles: [...ROLE_NAMES],
+        defaultRoles: [...VCM_ROLE_NAMES],
         handoffRoot: DEFAULT_HANDOFF_ROOT,
         stateRoot: DEFAULT_STATE_ROOT,
         terminalBackend: "node-pty",

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

@@ -134,6 +134,32 @@ export function createRoundService(deps) {
         }, delayMs);
         settleTimers.set(getRoundStatePath(input), timer);
     }
+    async function recordRoleTurnEvent(input) {
+        return withTaskLock(input, async () => {
+            const timestamp = now();
+            const settled = await settleIfNeeded(input, await load(input), timestamp);
+            const current = settled.currentRound;
+            const shouldStartNewRound = input.eventName === "UserPromptSubmit" && (!current || current.status === "stopped");
+            const next = applyRoundHookEvent({
+                state: settled,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                eventName: input.eventName,
+                timestamp,
+                roundId: shouldStartNewRound ? id() : current?.id ?? "",
+                settleMs
+            });
+            await save(input, next);
+            if (input.eventName === "UserPromptSubmit") {
+                clearSettleTimer(input);
+                await updateSessionStatus(input, "running");
+            }
+            else if (next.currentRound) {
+                scheduleSettleTimer(input, next.currentRound, timestamp, input.settleGuard);
+            }
+            return toSessionRoundState(next, timestamp);
+        });
+    }
     async function withTaskLock(input, run) {
         const key = getRoundStatePath(input);
         const previous = taskLocks.get(key) ?? Promise.resolve();
@@ -155,31 +181,9 @@ export function createRoundService(deps) {
                 return toSessionRoundState(await load(input), timestamp);
             });
         },
-        async recordClaudeHookEvent(input) {
-            return withTaskLock(input, async () => {
-                const timestamp = now();
-                const settled = await settleIfNeeded(input, await load(input), timestamp);
-                const current = settled.currentRound;
-                const shouldStartNewRound = input.eventName === "UserPromptSubmit" && (!current || current.status === "stopped");
-                const next = applyRoundHookEvent({
-                    state: settled,
-                    taskSlug: input.taskSlug,
-                    role: input.role,
-                    eventName: input.eventName,
-                    timestamp,
-                    roundId: shouldStartNewRound ? id() : current?.id ?? "",
-                    settleMs
-                });
-                await save(input, next);
-                if (input.eventName === "UserPromptSubmit") {
-                    clearSettleTimer(input);
-                    await updateSessionStatus(input, "running");
-                }
-                else if (next.currentRound) {
-                    scheduleSettleTimer(input, next.currentRound, timestamp, input.settleGuard);
-                }
-                return toSessionRoundState(next, timestamp);
-            });
+        recordRoleTurnEvent,
+        recordClaudeHookEvent(input) {
+            return recordRoleTurnEvent(input);
         },
         stopSession() { },
         stopTask(taskSlug) {