vibe-coding-master 0.3.26 → 0.3.28

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

@@ -1,6 +1,5 @@
 import { isCodexRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
-import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createCodexHookService(deps) {
     async function getHookContext(input) {
         if (!isCodexRoleName(input.role)) {
@@ -18,20 +17,8 @@ export function createCodexHookService(deps) {
                 statusCode: 409
             });
         }
-        if (input.role === "codex-translator") {
-            return {
-                project,
-                config: undefined,
-                taskRepoRoot: undefined
-            };
-        }
-        const config = await deps.projectService.loadConfig(project.repoRoot);
-        const task = await deps.taskService.loadTask(project.repoRoot, input.taskSlug);
-        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         return {
-            project,
-            config,
-            taskRepoRoot
+            project
         };
     }
     async function processHook(input, expectedEventName) {
@@ -44,42 +31,13 @@ export function createCodexHookService(deps) {
             });
         }
         const context = await getHookContext(input);
-        const session = input.role === "codex-translator"
-            ? await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
-                eventName,
-                sessionId: stringOrUndefined(input.event.session_id),
-                transcriptPath: stringOrUndefined(input.event.transcript_path),
-                cwd: stringOrUndefined(input.event.cwd)
-            })
-            : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
-                taskSlug: input.taskSlug,
-                role: input.role,
-                eventName,
-                sessionId: stringOrUndefined(input.event.session_id),
-                transcriptPath: stringOrUndefined(input.event.transcript_path),
-                cwd: stringOrUndefined(input.event.cwd),
-                allowSessionMismatch: true
-            });
-        if (input.role === "codex-reviewer") {
-            if (!context.config || !context.taskRepoRoot) {
-                throw new VcmError({
-                    code: "CODEX_HOOK_TASK_CONTEXT_MISSING",
-                    message: "Codex Reviewer hook is missing task context.",
-                    statusCode: 500
-                });
-            }
-            await deps.roundService.recordRoleTurnEvent({
-                repoRoot: context.project.repoRoot,
-                stateRepoRoot: context.taskRepoRoot,
-                stateRoot: context.config.stateRoot,
-                taskSlug: input.taskSlug,
-                role: input.role,
-                eventName
-            });
-        }
-        if (input.role === "codex-translator") {
-            await deps.codexTranslationService?.handleCodexHook(context.project.repoRoot, eventName, input.taskSlug);
-        }
+        const session = await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
+            eventName,
+            sessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd)
+        });
+        await deps.codexTranslationService?.handleCodexHook(context.project.repoRoot, eventName, input.taskSlug);
         return {
             ok: true,
             eventName,

package/dist/backend/services/{codex-review-service.js → gate-review-service.js}

@@ -1,16 +1,15 @@
 import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
-import { CODEX_REVIEW_GATES } from "../../shared/types/codex-review.js";
+import { GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.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 GATE_REVIEW_AGENT_PATH = ".claude/agents/gate-reviewer.md";
+const GATE_REVIEW_DIR = ".ai/vcm/gate-reviews";
+const REQUESTS_DIR = ".ai/vcm/gate-reviews/requests";
+const GATE_REVIEW_VERSION = 1;
+const GATE_REVIEWER_ROLE = "gate-reviewer";
 const DEFAULT_REPORT_POLL_INTERVAL_MS = 1000;
 const DEFAULT_REPORT_TIMEOUT_MS = 30 * 60 * 1000;
 const activeRuns = new Set();
@@ -30,7 +29,7 @@ const SOURCE_ARTIFACTS = {
     ]
 };
 const VALID_SEVERITIES = new Set(["critical", "high", "medium", "low"]);
-export function createCodexReviewService(deps) {
+export function createGateReviewService(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;
@@ -38,7 +37,7 @@ export function createCodexReviewService(deps) {
         const projectConfig = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-        const reviewSettings = await deps.appSettings.getCodexReviewSettings(repoRoot, taskSlug);
+        const reviewSettings = await deps.appSettings.getGateReviewSettings(repoRoot, taskSlug);
         return {
             repoRoot,
             taskSlug,
@@ -59,7 +58,7 @@ export function createCodexReviewService(deps) {
                 error: undefined
             }, now());
             await saveIndex(deps.fs, context.taskRepoRoot, index);
-            return { status: "disabled", gate, record: index.gates[gate], message: "Codex review is disabled." };
+            return { status: "disabled", gate, record: index.gates[gate], message: "Gate review is disabled." };
         }
         if (!record.required) {
             index = applyGateState(index, gate, {
@@ -75,11 +74,11 @@ export function createCodexReviewService(deps) {
                 status: "running",
                 gate,
                 record,
-                message: `Codex review is already running for ${index.activeGate}.`
+                message: `Gate review is already running for ${index.activeGate}.`
             };
         }
         if (record.status === "running" && !options.force) {
-            return { status: "running", gate, record, message: "Codex review is already running." };
+            return { status: "running", gate, record, message: "Gate review is already running." };
         }
         const inputHash = await computeInputHash(deps, context.taskRepoRoot, gate);
         if (!options.force
@@ -90,12 +89,13 @@ export function createCodexReviewService(deps) {
                 status: "already_approved",
                 gate,
                 record,
-                message: "Codex review already approved the current inputs."
+                message: "Gate review already approved the current inputs."
             };
         }
         const timestamp = now();
         const requestId = createRequestId(gate);
         const requestPath = path.posix.join(REQUESTS_DIR, `${requestId}.json`);
+        const promptPath = path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
         const nextRecord = {
             ...record,
             status: "running",
@@ -104,6 +104,7 @@ export function createCodexReviewService(deps) {
             exceptionReason: undefined,
             requestId,
             requestPath,
+            promptPath,
             inputHash,
             requestedAt: timestamp,
             startedAt: undefined,
@@ -122,7 +123,7 @@ export function createCodexReviewService(deps) {
             updatedAt: timestamp
         };
         await deps.fs.writeJsonAtomic(resolveRepoPath(context.taskRepoRoot, requestPath), {
-            version: CODEX_REVIEW_VERSION,
+            version: GATE_REVIEW_VERSION,
             requestId,
             gate,
             status: "requested",
@@ -132,23 +133,23 @@ export function createCodexReviewService(deps) {
             promptPath: nextRecord.promptPath
         });
         await saveIndex(deps.fs, context.taskRepoRoot, index);
-        void runCodexReview(context, gate, requestId).catch(() => {
-            // runCodexReview records failures in the persisted gate state.
+        void runGateReview(context, gate, requestId).catch(() => {
+            // runGateReview records failures in the persisted gate state.
         });
         return {
             status: "started",
             gate,
             record: nextRecord,
-            message: "Codex review started."
+            message: "Gate review started."
         };
     }
-    async function runCodexReview(context, gate, requestId) {
+    async function runGateReview(context, gate, requestId) {
         const runKey = `${context.taskRepoRoot}:${context.taskSlug}:${gate}`;
         if (activeRuns.has(runKey)) {
             return;
         }
         activeRuns.add(runKey);
-        let codexTurnStarted = false;
+        let gateTurnStarted = false;
         try {
             const timestamp = now();
             await updateGateRecord(context, gate, {
@@ -157,37 +158,39 @@ export function createCodexReviewService(deps) {
                 updatedAt: timestamp
             });
             await updateRequestStatus(deps.fs, context, requestId, "running", { startedAt: timestamp });
-            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 reviewDir = resolveRepoPath(context.taskRepoRoot, GATE_REVIEW_DIR);
+            const agentPath = resolveRepoPath(context.repoRoot, GATE_REVIEW_AGENT_PATH);
+            const prompt = buildGatePrompt(context, gate, requestId);
             await deps.fs.ensureDir(reviewDir);
-            if (!(await deps.fs.pathExists(codexDir))) {
+            await deps.fs.ensureDir(resolveRepoPath(context.taskRepoRoot, REQUESTS_DIR));
+            await deps.fs.writeText(resolveRepoPath(context.taskRepoRoot, promptPathForRequest(requestId)), prompt);
+            if (!(await deps.fs.pathExists(agentPath))) {
                 throw new VcmError({
-                    code: "CODEX_REVIEW_CONFIG_MISSING",
-                    message: `${CODEX_DIR} does not exist.`,
+                    code: "GATE_REVIEW_AGENT_MISSING",
+                    message: `${GATE_REVIEW_AGENT_PATH} does not exist.`,
                     statusCode: 409,
-                    hint: "Apply the VCM harness before requesting Codex review gates."
+                    hint: "Apply the VCM harness before requesting Gate Review Gates."
                 });
             }
-            const session = await ensureCodexReviewerSession(context);
+            const session = await ensureGateReviewerSession(context);
             await submitTerminalInput(deps.runtime, session.id, prompt);
-            await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
+            await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, GATE_REVIEWER_ROLE);
             await deps.roundService.recordRoleTurnEvent({
                 repoRoot: context.repoRoot,
                 stateRepoRoot: context.taskRepoRoot,
                 stateRoot: context.stateRoot,
                 taskSlug: context.taskSlug,
-                role: CODEX_REVIEWER_ROLE,
+                role: GATE_REVIEWER_ROLE,
                 eventName: "UserPromptSubmit"
             });
-            codexTurnStarted = true;
+            gateTurnStarted = true;
             const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), {
                 intervalMs: reportPollIntervalMs,
                 timeoutMs: reportTimeoutMs
             });
             const completedAt = now();
-            await recordCodexReviewerTurnStop(context, codexTurnStarted);
-            codexTurnStarted = false;
+            await recordGateReviewerTurnStop(context, gateTurnStarted);
+            gateTurnStarted = false;
             await updateGateRecord(context, gate, {
                 status: "completed",
                 decision: parsed.decision,
@@ -209,8 +212,8 @@ export function createCodexReviewService(deps) {
         catch (error) {
             const timestamp = now();
             const message = errorMessage(error);
-            await recordCodexReviewerTurnStop(context, codexTurnStarted);
-            codexTurnStarted = false;
+            await recordGateReviewerTurnStop(context, gateTurnStarted);
+            gateTurnStarted = false;
             await updateGateRecord(context, gate, {
                 status: "failed",
                 error: message,
@@ -229,38 +232,38 @@ export function createCodexReviewService(deps) {
             activeRuns.delete(runKey);
         }
     }
-    async function recordCodexReviewerTurnStop(context, shouldRecord) {
+    async function recordGateReviewerTurnStop(context, shouldRecord) {
         if (!shouldRecord) {
             return;
         }
-        await deps.sessionService.markRoleActivityIdle(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
+        await deps.sessionService.markRoleActivityIdle(context.repoRoot, context.taskSlug, GATE_REVIEWER_ROLE);
         await deps.roundService.recordRoleTurnEvent({
             repoRoot: context.repoRoot,
             stateRepoRoot: context.taskRepoRoot,
             stateRoot: context.stateRoot,
             taskSlug: context.taskSlug,
-            role: CODEX_REVIEWER_ROLE,
+            role: GATE_REVIEWER_ROLE,
             eventName: "Stop"
         });
     }
-    async function ensureCodexReviewerSession(context) {
-        const existing = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE);
+    async function ensureGateReviewerSession(context) {
+        const existing = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, GATE_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, {
+                return await deps.sessionService.resumeRoleSession(context.repoRoot, context.taskSlug, GATE_REVIEWER_ROLE, {
                     cols: 100,
                     rows: 28,
                     model: "default"
                 });
             }
             catch {
-                // Fall through to a fresh Codex Reviewer terminal if the saved session cannot be resumed.
+                // Fall through to a fresh Gate Reviewer terminal if the saved session cannot be resumed.
             }
         }
-        return deps.sessionService.startRoleSession(context.repoRoot, context.taskSlug, CODEX_REVIEWER_ROLE, {
+        return deps.sessionService.startRoleSession(context.repoRoot, context.taskSlug, GATE_REVIEWER_ROLE, {
             cols: 100,
             rows: 28,
             model: "default"
@@ -321,10 +324,10 @@ export function createCodexReviewService(deps) {
             return loadIndex(deps.fs, context, now());
         },
         async updateSettings(repoRoot, taskSlug, input) {
-            const currentSettings = await deps.appSettings.getCodexReviewSettings(repoRoot, taskSlug);
+            const currentSettings = await deps.appSettings.getGateReviewSettings(repoRoot, taskSlug);
             const requiredGates = new Set(currentSettings.requiredGates);
             for (const [gate, enabled] of Object.entries(input?.gates ?? {})) {
-                if (!isCodexReviewGate(gate)) {
+                if (!isGateReviewGate(gate)) {
                     continue;
                 }
                 if (enabled) {
@@ -334,7 +337,7 @@ export function createCodexReviewService(deps) {
                     requiredGates.delete(gate);
                 }
             }
-            await deps.appSettings.updateCodexReviewSettings(repoRoot, taskSlug, [...requiredGates]);
+            await deps.appSettings.updateGateReviewSettings(repoRoot, taskSlug, [...requiredGates]);
             const nextContext = await getContext(repoRoot, taskSlug);
             const index = await loadIndex(deps.fs, nextContext, now());
             await saveIndex(deps.fs, nextContext.taskRepoRoot, {
@@ -355,10 +358,10 @@ export function createCodexReviewService(deps) {
             const current = await loadIndex(deps.fs, context, now());
             if (current.gates[gate].status === "running") {
                 throw new VcmError({
-                    code: "CODEX_REVIEW_RUNNING",
-                    message: "Cannot skip a running Codex review gate.",
+                    code: "GATE_REVIEW_RUNNING",
+                    message: "Cannot skip a running Gate review gate.",
                     statusCode: 409,
-                    hint: "Wait for the Codex run to finish, then choose retry, skip, or override."
+                    hint: "Wait for the gate review to finish, then choose retry, skip, or override."
                 });
             }
             const index = await updateGateRecord(context, gate, {
@@ -380,10 +383,10 @@ export function createCodexReviewService(deps) {
             const current = await loadIndex(deps.fs, context, now());
             if (current.gates[gate].status === "running") {
                 throw new VcmError({
-                    code: "CODEX_REVIEW_RUNNING",
-                    message: "Cannot override a running Codex review gate.",
+                    code: "GATE_REVIEW_RUNNING",
+                    message: "Cannot override a running Gate review gate.",
                     statusCode: 409,
-                    hint: "Wait for the Codex run to finish, then choose retry, skip, or override."
+                    hint: "Wait for the gate review to finish, then choose retry, skip, or override."
                 });
             }
             const index = await updateGateRecord(context, gate, {
@@ -405,8 +408,8 @@ export function createCodexReviewService(deps) {
         }
     };
 }
-export function isCodexReviewGate(value) {
-    return CODEX_REVIEW_GATES.includes(value);
+export function isGateReviewGate(value) {
+    return GATE_REVIEW_GATES.includes(value);
 }
 function loadRuntimeConfig(reviewSettings) {
     return {
@@ -425,7 +428,7 @@ function normalizeIndex(raw, config, timestamp) {
         : {};
     const gates = {};
     const requiredSet = new Set(config.enabled ? config.requiredGates : []);
-    for (const gate of CODEX_REVIEW_GATES) {
+    for (const gate of GATE_REVIEW_GATES) {
         const existing = existingGates[gate];
         const required = requiredSet.has(gate);
         const fallbackStatus = config.enabled
@@ -457,11 +460,11 @@ function normalizeIndex(raw, config, timestamp) {
             callbackError: typeof existing?.callbackError === "string" ? existing.callbackError : undefined
         };
     }
-    const activeGate = isCodexReviewGate(String(raw?.activeGate)) && gates[raw?.activeGate].status === "running"
+    const activeGate = isGateReviewGate(String(raw?.activeGate)) && gates[raw?.activeGate].status === "running"
         ? raw?.activeGate
         : null;
     return {
-        version: CODEX_REVIEW_VERSION,
+        version: GATE_REVIEW_VERSION,
         enabled: config.enabled,
         activeGate,
         gates,
@@ -494,11 +497,9 @@ async function computeInputHash(deps, taskRepoRoot, gate) {
     const digest = createHash("sha256");
     const common = [
         "CLAUDE.md",
-        ".ai/codex/AGENTS.md",
-        ".ai/codex/config.toml",
-        ".ai/codex/.codex/config.toml",
-        ".ai/codex/.codex/hooks.json",
-        promptPathForGate(gate)
+        ".claude/agents/gate-reviewer.md",
+        ".claude/skills/vcm-gate-review/SKILL.md",
+        ".ai/tools/request-gate-review"
     ];
     for (const relativePath of [...common, ...SOURCE_ARTIFACTS[gate]]) {
         digest.update(relativePath);
@@ -521,35 +522,31 @@ async function commandStdout(runner, cwd, args) {
     const result = await runner.run("git", args, { cwd });
     return result.exitCode === 0 ? result.stdout : "";
 }
-async function buildCodexPrompt(fs, taskRepoRoot, gate, requestId) {
-    const promptPath = resolveRepoPath(taskRepoRoot, promptPathForGate(gate));
-    if (!(await fs.pathExists(promptPath))) {
-        throw new VcmError({
-            code: "CODEX_REVIEW_PROMPT_MISSING",
-            message: `Codex review prompt is missing: ${promptPathForGate(gate)}`,
-            statusCode: 409,
-            hint: "Apply the VCM harness before requesting Codex review gates."
-        });
-    }
-    const basePrompt = await fs.readText(promptPath);
-    const reportPath = path.posix.relative(CODEX_DIR, reportPathForGate(gate));
-    return `${basePrompt.trimEnd()}
-
-## VCM Runtime Contract
-
-- Gate: ${gate}
-- Request: ${requestId}
-- Report path from this working directory: ${reportPath}
+function buildGatePrompt(context, gate, requestId) {
+    const reportPath = reportPathForGate(gate);
+    const absoluteReportPath = resolveRepoPath(context.taskRepoRoot, reportPath);
+    const evidence = SOURCE_ARTIFACTS[gate]
+        .map((relativePath) => `- ${relativePath}`)
+        .join("\n");
+    const gitLine = gate === "architecture-plan" || gate === "final-diff"
+        ? "\nDiff: inspect git status/diff in Worktree."
+        : "";
+    return `[VCM GATE REVIEW]
+Task: ${context.taskSlug}
+Worktree: ${context.taskRepoRoot}
+Gate: ${gate}
+Request: ${requestId}
+Report: ${absoluteReportPath}
 
-Your report must begin with these exact fields:
+Evidence:
+${evidence}${gitLine}
 
-\`\`\`text
+Write only Report. Start exactly:
 Gate: ${gate}
 Request: ${requestId}
 Decision: approve|request_changes
-\`\`\`
-
-Write only that report file. Do not edit any other file.`;
+Summary: <one or two sentences>
+[/VCM GATE REVIEW]`;
 }
 async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, options) {
     const startedAt = Date.now();
@@ -568,8 +565,8 @@ async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, o
     }
     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.`,
+        code: "GATE_REVIEW_REPORT_TIMEOUT",
+        message: `Gate Reviewer did not produce a valid ${gate} report within ${Math.round(options.timeoutMs / 1000)}s.`,
         statusCode: 504,
         hint: detail
     });
@@ -579,8 +576,8 @@ async function parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp) {
     const absolutePath = resolveRepoPath(taskRepoRoot, reportPath);
     if (!(await fs.pathExists(absolutePath))) {
         throw new VcmError({
-            code: "CODEX_REVIEW_REPORT_MISSING",
-            message: `Codex review report was not written: ${reportPath}`,
+            code: "GATE_REVIEW_REPORT_MISSING",
+            message: `Gate review report was not written: ${reportPath}`,
             statusCode: 500
         });
     }
@@ -588,24 +585,24 @@ async function parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp) {
     const parsedGate = matchField(content, "Gate");
     if (parsedGate && parsedGate !== gate) {
         throw new VcmError({
-            code: "CODEX_REVIEW_REPORT_GATE_MISMATCH",
-            message: `Codex review report gate is ${parsedGate}, expected ${gate}.`,
+            code: "GATE_REVIEW_REPORT_GATE_MISMATCH",
+            message: `Gate review report gate is ${parsedGate}, expected ${gate}.`,
             statusCode: 500
         });
     }
     const parsedRequest = matchField(content, "Request");
     if (requestId && parsedRequest !== requestId) {
         throw new VcmError({
-            code: "CODEX_REVIEW_REPORT_STALE",
-            message: `Codex review report request is ${parsedRequest ?? "missing"}, expected ${requestId}.`,
+            code: "GATE_REVIEW_REPORT_STALE",
+            message: `Gate review report request is ${parsedRequest ?? "missing"}, expected ${requestId}.`,
             statusCode: 500
         });
     }
     const decision = normalizeDecision(matchField(content, "Decision"));
     if (!decision) {
         throw new VcmError({
-            code: "CODEX_REVIEW_DECISION_MISSING",
-            message: `Codex review report must contain Decision: approve or Decision: request_changes.`,
+            code: "GATE_REVIEW_DECISION_MISSING",
+            message: `Gate review report must contain Decision: approve or Decision: request_changes.`,
             statusCode: 500
         });
     }
@@ -623,7 +620,7 @@ async function parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp) {
 async function updateRequestStatus(fs, context, requestId, status, patch) {
     const requestPath = resolveRepoPath(context.taskRepoRoot, path.posix.join(REQUESTS_DIR, `${requestId}.json`));
     const current = await readJsonOrNull(fs, requestPath) ?? {
-        version: CODEX_REVIEW_VERSION,
+        version: GATE_REVIEW_VERSION,
         requestId
     };
     await fs.writeJsonAtomic(requestPath, {
@@ -634,13 +631,16 @@ async function updateRequestStatus(fs, context, requestId, status, patch) {
     });
 }
 function reportPathForGate(gate) {
-    return path.posix.join(CODEX_REVIEW_DIR, `${gate}-review.md`);
+    return path.posix.join(GATE_REVIEW_DIR, `${gate}-review.md`);
+}
+function promptPathForRequest(requestId) {
+    return path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
 }
 function promptPathForGate(gate) {
-    return path.posix.join(CODEX_DIR, "prompts", `${gate}-gate.md`);
+    return path.posix.join(GATE_REVIEW_DIR, "prompts", `${gate}-gate.md`);
 }
 function getIndexPath(taskRepoRoot) {
-    return resolveRepoPath(taskRepoRoot, path.posix.join(CODEX_REVIEW_DIR, "index.json"));
+    return resolveRepoPath(taskRepoRoot, path.posix.join(GATE_REVIEW_DIR, "index.json"));
 }
 function createRequestId(gate) {
     const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
@@ -736,7 +736,7 @@ function parsePositiveInteger(value) {
 function assertExceptionReason(reason) {
     if (!reason?.trim()) {
         throw new VcmError({
-            code: "CODEX_REVIEW_REASON_REQUIRED",
+            code: "GATE_REVIEW_REASON_REQUIRED",
             message: "A reason is required.",
             statusCode: 400
         });
@@ -744,7 +744,7 @@ function assertExceptionReason(reason) {
 }
 function renderProjectManagerCallback(input) {
     const lines = [
-        "[VCM CODEX REVIEW CALLBACK]",
+        "[VCM GATE REVIEW CALLBACK]",
         `task: ${input.taskSlug}`,
         `gate: ${input.gate}`,
         `status: ${input.status}`,
@@ -752,11 +752,11 @@ function renderProjectManagerCallback(input) {
         `report: ${input.reportPath}`,
         ...(input.error ? [`error: ${input.error}`] : []),
         "",
-        "Use the vcm-codex-review-gate skill to handle this callback.",
+        "Use the vcm-gate-review skill to handle this callback.",
         "If status is completed and decision is approve, continue the VCM flow.",
         "If decision is request_changes, analyze the report and route follow-up through the normal VCM roles.",
         "If status is failed, stop and ask the user to retry, skip, or override in VCM.",
-        "[/VCM CODEX REVIEW CALLBACK]"
+        "[/VCM GATE REVIEW CALLBACK]"
     ];
     return lines.join("\n");
 }
@@ -767,14 +767,14 @@ function errorMessage(error) {
     if (error instanceof Error) {
         return error.message;
     }
-    return "Unknown Codex review error.";
+    return "Unknown Gate 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"
+        "GATE_REVIEW_DECISION_MISSING",
+        "GATE_REVIEW_REPORT_GATE_MISMATCH",
+        "GATE_REVIEW_REPORT_MISSING",
+        "GATE_REVIEW_REPORT_STALE"
     ].includes(error.code);
 }
 function delay(ms) {