vibe-coding-master 0.3.26 → 0.3.28

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, renderCodexCliConfigHarnessRules, renderCodexConfigHarnessRules, renderCodexFinalDiffPrompt, renderCodexHooksHarnessRules, renderCodexReviewResultSchema, renderCodexTranslatorAgentsHarnessRules, renderCodexTranslatorConfigHarnessRules, renderCodexValidationAdequacyPrompt, renderRequestCodexReviewTool, renderVcmCodexReviewGateSkillRules } from "../templates/harness/codex-review.js";
+import { renderCodexCliConfigHarnessRules, renderCodexHooksHarnessRules, renderCodexTranslatorAgentsHarnessRules, renderCodexTranslatorConfigHarnessRules, renderGateReviewerAgentRules, renderRequestGateReviewTool, renderVcmGateReviewSkillRules } from "../templates/harness/gate-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";
@@ -92,39 +92,19 @@ const HARNESS_FILES = [
         renderRules: renderVcmLongRunningValidationSkillRules
     },
     {
-        kind: "skill-vcm-codex-review-gate",
-        path: ".claude/skills/vcm-codex-review-gate/SKILL.md",
-        title: "VCM Codex Review Gate Skill",
-        frontmatter: renderSkillFrontmatter("vcm-codex-review-gate", "Use when project-manager reaches a Codex Review Gate or receives a VCM Codex Review callback."),
+        kind: "skill-vcm-gate-review",
+        path: ".claude/skills/vcm-gate-review/SKILL.md",
+        title: "VCM Gate Review Skill",
+        frontmatter: renderSkillFrontmatter("vcm-gate-review", "Use when project-manager reaches a Gate Review trigger or receives a VCM Gate Review callback."),
         ownership: "whole-file",
-        renderRules: renderVcmCodexReviewGateSkillRules
+        renderRules: renderVcmGateReviewSkillRules
     },
     {
-        kind: "codex-agents",
-        path: ".ai/codex/AGENTS.md",
-        title: "VCM Codex Reviewer",
-        renderRules: renderCodexAgentsHarnessRules
-    },
-    {
-        kind: "codex-config",
-        path: ".ai/codex/config.toml",
-        title: "VCM Codex Config",
-        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: "agent-gate-reviewer",
+        path: ".claude/agents/gate-reviewer.md",
+        title: "Gate Reviewer Agent",
+        frontmatter: renderAgentFrontmatter("gate-reviewer", "VCM independent gate review role for architecture plans, validation adequacy, and final diffs."),
+        renderRules: renderGateReviewerAgentRules
     },
     {
         kind: "codex-translator-agents",
@@ -154,39 +134,11 @@ const HARNESS_FILES = [
         renderRules: () => renderCodexHooksHarnessRules("codex-translator")
     },
     {
-        kind: "codex-prompt-architecture-plan",
-        path: ".ai/codex/prompts/architecture-plan-gate.md",
-        title: "Codex Architecture Plan Gate Prompt",
-        ownership: "raw-file",
-        renderRules: renderCodexArchitecturePlanPrompt
-    },
-    {
-        kind: "codex-prompt-validation-adequacy",
-        path: ".ai/codex/prompts/validation-adequacy-gate.md",
-        title: "Codex Validation Adequacy Gate Prompt",
-        ownership: "raw-file",
-        renderRules: renderCodexValidationAdequacyPrompt
-    },
-    {
-        kind: "codex-prompt-final-diff",
-        path: ".ai/codex/prompts/final-diff-gate.md",
-        title: "Codex Final Diff Gate Prompt",
-        ownership: "raw-file",
-        renderRules: renderCodexFinalDiffPrompt
-    },
-    {
-        kind: "codex-review-schema",
-        path: ".ai/codex/schemas/codex-review-result.schema.json",
-        title: "Codex Review Result Schema",
-        ownership: "raw-file",
-        renderRules: renderCodexReviewResultSchema
-    },
-    {
-        kind: "tool-request-codex-review",
-        path: ".ai/tools/request-codex-review",
-        title: "Request Codex Review Tool",
+        kind: "tool-request-gate-review",
+        path: ".ai/tools/request-gate-review",
+        title: "Request Gate Review Tool",
         ownership: "raw-file",
-        renderRules: renderRequestCodexReviewTool
+        renderRules: renderRequestGateReviewTool
     },
     {
         kind: "agent-project-manager",

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

@@ -1,20 +1,19 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
-import { ROLE_NAMES, isCodexRoleName, isDispatchableRole } from "../../shared/constants.js";
+import { VCM_ROLE_NAMES, isCodexRoleName, isDispatchableRole } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { claudeTranscriptPath } from "./claude-transcript-service.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
-const CODEX_REVIEWER_ROLE = "codex-reviewer";
+const GATE_REVIEWER_ROLE = "gate-reviewer";
 const CODEX_TRANSLATOR_ROLE = "codex-translator";
-const CODEX_DIR = ".ai/codex";
-const CODEX_REVIEW_DIR = ".ai/vcm/codex-reviews";
-const CODEX_CONFIG_PATH = ".ai/codex/config.toml";
 const CODEX_TRANSLATOR_DIR = ".ai/codex-translator";
 const CODEX_TRANSLATION_DIR = ".ai/vcm/translations";
 const CODEX_TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
 const CODEX_TRANSLATOR_CONFIG_PATH = ".ai/codex-translator/config.toml";
+const GATE_REVIEWER_SESSION_PATH = ".ai/vcm/gate-reviewer/session.json";
 const PROJECT_TRANSLATOR_SCOPE = "__project__";
+const PROJECT_GATE_REVIEWER_SCOPE = "__project_gate_reviewer__";
 export function createSessionService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
@@ -102,6 +101,75 @@ export function createSessionService(deps) {
         await persistRoleSessionRecord(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, record);
         return record;
     }
+    async function launchProjectGateReviewerSession(repoRoot, input, launchMode) {
+        const live = toRoleSessionRecordView(getRegisteredProjectGateReviewerSession(deps.registry, deps.runtime), deps.runtime);
+        if (live && live.status === "running") {
+            return live;
+        }
+        const config = await deps.projectService.loadConfig(repoRoot);
+        const persisted = await loadPersistedProjectGateReviewerSession(deps.fs, repoRoot);
+        const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
+        const model = normalizeClaudeModel(input.model ?? persisted?.model);
+        const effort = normalizeClaudeEffort(input.effort ?? persisted?.effort);
+        const claudeSessionId = launchMode === "resume"
+            ? persisted?.claudeSessionId
+            : randomUUID();
+        if (!claudeSessionId) {
+            throw new VcmError({
+                code: "GATE_REVIEWER_SESSION_MISSING",
+                message: "Gate Reviewer does not have a session id to resume.",
+                statusCode: 409,
+                hint: "Start Gate Reviewer once before using Resume."
+            });
+        }
+        const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
+            ? persisted.transcriptPath
+            : claudeTranscriptPath(repoRoot, claudeSessionId);
+        const startCommand = {
+            ...deps.claude.buildRoleStartCommand(GATE_REVIEWER_ROLE, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model, effort),
+            cwd: repoRoot
+        };
+        const runtimeSession = await deps.runtime.createSession({
+            taskSlug: PROJECT_GATE_REVIEWER_SCOPE,
+            role: GATE_REVIEWER_ROLE,
+            command: startCommand.command,
+            args: startCommand.args,
+            cwd: startCommand.cwd,
+            env: {
+                VCM_API_URL: deps.apiUrl,
+                VCM_TASK_REPO_ROOT: repoRoot,
+                VCM_TASK_SLUG: PROJECT_GATE_REVIEWER_SCOPE,
+                VCM_ROLE: GATE_REVIEWER_ROLE,
+                VCM_SESSION_ID: claudeSessionId
+            },
+            cols: input.cols,
+            rows: input.rows
+        });
+        const timestamp = now();
+        const record = {
+            id: runtimeSession.id,
+            claudeSessionId,
+            transcriptPath,
+            taskSlug: PROJECT_GATE_REVIEWER_SCOPE,
+            role: GATE_REVIEWER_ROLE,
+            status: runtimeSession.status,
+            activityStatus: "idle",
+            command: startCommand.display,
+            permissionMode,
+            model,
+            effort,
+            cwd: startCommand.cwd,
+            terminalBackend: "node-pty",
+            pid: runtimeSession.pid,
+            startedAt: runtimeSession.startedAt,
+            updatedAt: timestamp,
+            lastOutputAt: runtimeSession.lastOutputAt,
+            exitCode: runtimeSession.exitCode
+        };
+        deps.registry.upsert(record);
+        await persistProjectGateReviewerSession(deps.fs, repoRoot, record);
+        return record;
+    }
     async function launchProjectTranslatorSession(repoRoot, input, launchMode) {
         const live = toRoleSessionRecordView(getRegisteredProjectTranslatorSession(deps.registry, deps.runtime), deps.runtime);
         if (live && live.status === "running") {
@@ -163,6 +231,67 @@ export function createSessionService(deps) {
         return record;
     }
     return {
+        startProjectGateReviewerSession(repoRoot, input = {}) {
+            return launchProjectGateReviewerSession(repoRoot, input, "fresh");
+        },
+        resumeProjectGateReviewerSession(repoRoot, input = {}) {
+            return launchProjectGateReviewerSession(repoRoot, input, "resume");
+        },
+        async stopProjectGateReviewerSession(repoRoot) {
+            const existing = await this.getProjectGateReviewerSession(repoRoot);
+            if (!existing) {
+                throw new VcmError({
+                    code: "SESSION_MISSING",
+                    message: "Gate Reviewer session has not been started.",
+                    statusCode: 404
+                });
+            }
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            const updated = {
+                ...existing,
+                taskSlug: PROJECT_GATE_REVIEWER_SCOPE,
+                status: "exited",
+                activityStatus: "idle",
+                updatedAt: now()
+            };
+            deps.registry.upsert(updated);
+            await persistProjectGateReviewerSession(deps.fs, repoRoot, updated);
+            return updated;
+        },
+        async restartProjectGateReviewerSession(repoRoot, input = {}) {
+            const existing = await this.getProjectGateReviewerSession(repoRoot);
+            if (!existing) {
+                return launchProjectGateReviewerSession(repoRoot, input, "fresh");
+            }
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            deps.registry.remove(existing.id);
+            return launchProjectGateReviewerSession(repoRoot, input, "fresh");
+        },
+        async getProjectGateReviewerSession(repoRoot) {
+            const record = getRegisteredProjectGateReviewerSession(deps.registry, deps.runtime)
+                ?? await loadPersistedProjectGateReviewerSession(deps.fs, repoRoot);
+            return toRoleSessionRecordView(record, deps.runtime);
+        },
+        async ensureProjectGateReviewerSession(repoRoot, input = {}) {
+            const existing = await this.getProjectGateReviewerSession(repoRoot);
+            if (existing?.status === "running") {
+                return existing;
+            }
+            if (existing?.claudeSessionId) {
+                return this.resumeProjectGateReviewerSession(repoRoot, {
+                    permissionMode: input.permissionMode ?? existing.permissionMode,
+                    model: input.model ?? existing.model,
+                    effort: input.effort ?? existing.effort,
+                    cols: input.cols,
+                    rows: input.rows
+                });
+            }
+            return this.startProjectGateReviewerSession(repoRoot, input);
+        },
         startProjectTranslatorSession(repoRoot, input = {}) {
             return launchProjectTranslatorSession(repoRoot, input, "fresh");
         },
@@ -247,6 +376,10 @@ export function createSessionService(deps) {
             return updated;
         },
         startRoleSession(repoRoot, taskSlug, role, input = {}) {
+            if (role === GATE_REVIEWER_ROLE) {
+                return this.startProjectGateReviewerSession(repoRoot, input)
+                    .then((session) => scopeProjectRoleSession(session, taskSlug));
+            }
             if (role === CODEX_TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.startProjectTranslatorSession(repoRoot, input);
@@ -254,6 +387,10 @@ export function createSessionService(deps) {
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
         resumeRoleSession(repoRoot, taskSlug, role, input = {}) {
+            if (role === GATE_REVIEWER_ROLE) {
+                return this.resumeProjectGateReviewerSession(repoRoot, input)
+                    .then((session) => scopeProjectRoleSession(session, taskSlug));
+            }
             if (role === CODEX_TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.resumeProjectTranslatorSession(repoRoot, input);
@@ -261,6 +398,9 @@ export function createSessionService(deps) {
             return launchRoleSession(repoRoot, taskSlug, role, input, "resume");
         },
         async stopRoleSession(repoRoot, taskSlug, role) {
+            if (role === GATE_REVIEWER_ROLE) {
+                return scopeProjectRoleSession(await this.stopProjectGateReviewerSession(repoRoot), taskSlug);
+            }
             if (role === CODEX_TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.stopProjectTranslatorSession(repoRoot);
@@ -289,6 +429,9 @@ export function createSessionService(deps) {
             return updated;
         },
         async restartRoleSession(repoRoot, taskSlug, role, input = {}) {
+            if (role === GATE_REVIEWER_ROLE) {
+                return scopeProjectRoleSession(await this.restartProjectGateReviewerSession(repoRoot, input), taskSlug);
+            }
             if (role === CODEX_TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.restartProjectTranslatorSession(repoRoot, input);
@@ -304,6 +447,9 @@ export function createSessionService(deps) {
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
         async getRoleSession(repoRoot, taskSlug, role) {
+            if (role === GATE_REVIEWER_ROLE) {
+                return scopeProjectRoleSession(await this.getProjectGateReviewerSession(repoRoot), taskSlug);
+            }
             if (role === CODEX_TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.getProjectTranslatorSession(repoRoot);
@@ -324,7 +470,7 @@ export function createSessionService(deps) {
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const persistedTaskSession = await loadPersistedTaskSessionRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug);
-            for (const role of ROLE_NAMES.filter((candidate) => candidate !== CODEX_TRANSLATOR_ROLE)) {
+            for (const role of VCM_ROLE_NAMES) {
                 const record = deps.registry.getByRole(taskSlug, role)
                     ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record);
                 const session = toRoleSessionRecordView(record, deps.runtime);
@@ -332,9 +478,38 @@ export function createSessionService(deps) {
                     sessions.push(session);
                 }
             }
+            const gateReviewerSession = scopeProjectRoleSession(await this.getProjectGateReviewerSession(repoRoot), taskSlug);
+            if (gateReviewerSession) {
+                sessions.push(gateReviewerSession);
+            }
             return sessions;
         },
         async recordRoleHookEvent(repoRoot, input) {
+            if (input.role === GATE_REVIEWER_ROLE) {
+                const current = await this.getProjectGateReviewerSession(repoRoot);
+                if (!current || (!input.allowSessionMismatch && !matchesRoleHookSession(current, input))) {
+                    return undefined;
+                }
+                const timestamp = now();
+                const isTurnEnd = isTurnEndHook(input.eventName);
+                const isCompact = isCompactHook(input.eventName);
+                const updated = {
+                    ...current,
+                    taskSlug: PROJECT_GATE_REVIEWER_SCOPE,
+                    claudeSessionId: input.sessionId ?? current.claudeSessionId,
+                    transcriptPath: input.transcriptPath ?? current.transcriptPath,
+                    cwd: input.cwd ?? current.cwd,
+                    activityStatus: isTurnEnd ? "idle" : isCompact ? current.activityStatus : "running",
+                    lastHookEventAt: timestamp,
+                    lastTurnEndedAt: isTurnEnd ? timestamp : current.lastTurnEndedAt,
+                    lastTurnStartedAt: isTurnEnd || isCompact ? current.lastTurnStartedAt : timestamp,
+                    lastCompactAt: isCompact ? timestamp : current.lastCompactAt,
+                    updatedAt: timestamp
+                };
+                deps.registry.upsert(updated);
+                await persistProjectGateReviewerSession(deps.fs, repoRoot, updated);
+                return scopeProjectRoleSession(updated, input.taskSlug);
+            }
             if (input.role === CODEX_TRANSLATOR_ROLE) {
                 void input.taskSlug;
                 return this.recordProjectTranslatorHookEvent(repoRoot, {
@@ -392,6 +567,15 @@ export function createSessionService(deps) {
                 lastHookEventAt: timestamp,
                 updatedAt: timestamp
             };
+            if (role === GATE_REVIEWER_ROLE) {
+                const persisted = {
+                    ...updated,
+                    taskSlug: PROJECT_GATE_REVIEWER_SCOPE
+                };
+                deps.registry.upsert(persisted);
+                await persistProjectGateReviewerSession(deps.fs, repoRoot, persisted);
+                return updated;
+            }
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
@@ -410,6 +594,15 @@ export function createSessionService(deps) {
                 lastTurnEndedAt: timestamp,
                 updatedAt: timestamp
             };
+            if (role === GATE_REVIEWER_ROLE) {
+                const persisted = {
+                    ...updated,
+                    taskSlug: PROJECT_GATE_REVIEWER_SCOPE
+                };
+                deps.registry.upsert(persisted);
+                await persistProjectGateReviewerSession(deps.fs, repoRoot, persisted);
+                return updated;
+            }
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
@@ -440,20 +633,27 @@ function toRoleSessionRecordView(record, runtime) {
         exitCode: runtimeSession.exitCode
     };
 }
-async function buildCodexStartCommand(fs, baseRepoRoot, taskRepoRoot, role, launchMode, selectedModel, selectedEffort, sandboxMode, resumeSessionId) {
+async function buildCodexStartCommand(fs, baseRepoRoot, _taskRepoRoot, role, launchMode, selectedModel, selectedEffort, sandboxMode, resumeSessionId) {
     const isTranslator = role === CODEX_TRANSLATOR_ROLE;
-    const codexDir = resolveRepoPath(isTranslator ? baseRepoRoot : taskRepoRoot, isTranslator ? CODEX_TRANSLATOR_DIR : CODEX_DIR);
-    const outputDir = resolveRepoPath(isTranslator ? baseRepoRoot : taskRepoRoot, isTranslator ? CODEX_TRANSLATION_DIR : CODEX_REVIEW_DIR);
+    if (!isTranslator) {
+        throw new VcmError({
+            code: "CODEX_ROLE_UNSUPPORTED",
+            message: `${role} is not a Codex role.`,
+            statusCode: 400
+        });
+    }
+    const codexDir = resolveRepoPath(baseRepoRoot, CODEX_TRANSLATOR_DIR);
+    const outputDir = resolveRepoPath(baseRepoRoot, CODEX_TRANSLATION_DIR);
     if (!(await fs.pathExists(codexDir))) {
         throw new VcmError({
-            code: isTranslator ? "CODEX_TRANSLATOR_CONFIG_MISSING" : "CODEX_REVIEW_CONFIG_MISSING",
-            message: `${isTranslator ? CODEX_TRANSLATOR_DIR : CODEX_DIR} does not exist.`,
+            code: "CODEX_TRANSLATOR_CONFIG_MISSING",
+            message: `${CODEX_TRANSLATOR_DIR} does not exist.`,
             statusCode: 409,
-            hint: `Apply the VCM harness before starting ${isTranslator ? "Codex Translator" : "Codex Reviewer"}.`
+            hint: "Apply the VCM harness before starting Codex Translator."
         });
     }
     await fs.ensureDir(outputDir);
-    const config = await loadCodexSessionConfig(fs, isTranslator ? baseRepoRoot : taskRepoRoot, isTranslator ? CODEX_TRANSLATOR_CONFIG_PATH : CODEX_CONFIG_PATH);
+    const config = await loadCodexSessionConfig(fs, baseRepoRoot, CODEX_TRANSLATOR_CONFIG_PATH);
     const args = launchMode === "resume"
         ? resumeSessionId ? ["resume", resumeSessionId] : ["resume", "--last"]
         : [];
@@ -462,12 +662,7 @@ async function buildCodexStartCommand(fs, baseRepoRoot, taskRepoRoot, role, laun
         args.push("--dangerously-bypass-approvals-and-sandbox");
     }
     else {
-        if (isTranslator) {
-            args.push("--add-dir", baseRepoRoot);
-        }
-        else {
-            args.push("--add-dir", outputDir);
-        }
+        args.push("--add-dir", baseRepoRoot);
         args.push("--sandbox", "workspace-write", "--ask-for-approval", "never");
     }
     args.push("--dangerously-bypass-hook-trust", "--search");
@@ -480,7 +675,7 @@ async function buildCodexStartCommand(fs, baseRepoRoot, taskRepoRoot, role, laun
     return {
         command: config.command,
         args,
-        cwd: isTranslator ? baseRepoRoot : taskRepoRoot,
+        cwd: baseRepoRoot,
         display: [config.command, ...args].map(formatDisplayArg).join(" ")
     };
 }
@@ -508,9 +703,8 @@ async function loadCodexSessionConfig(fs, repoRoot, configRelativePath) {
         };
     }
     const content = await fs.readText(configPath);
-    const reviewSection = extractTomlSection(content, "vcm.codex_review");
     return {
-        command: parseTomlString(content, "command") ?? parseTomlString(reviewSection, "command") ?? "codex"
+        command: parseTomlString(content, "command") ?? "codex"
     };
 }
 function matchesRoleHookSession(record, input) {
@@ -550,7 +744,7 @@ function getHandoffArtifactPath(paths, role) {
     return undefined;
 }
 function getRegisteredRoleSession(registry, runtime, taskSlug, role) {
-    if (role !== CODEX_TRANSLATOR_ROLE) {
+    if (role !== CODEX_TRANSLATOR_ROLE && role !== GATE_REVIEWER_ROLE) {
         return registry.getByRole(taskSlug, role);
     }
     const candidates = registry.list().filter((session) => session.role === role);
@@ -560,6 +754,11 @@ function getRegisteredRoleSession(registry, runtime, taskSlug, role) {
         ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
     return scopeProjectRoleSession(scoped, taskSlug);
 }
+function getRegisteredProjectGateReviewerSession(registry, runtime) {
+    const candidates = registry.list().filter((session) => session.role === GATE_REVIEWER_ROLE);
+    const live = candidates.find((session) => runtime.getSession(session.id)?.status === "running");
+    return live ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
+}
 function getRegisteredProjectTranslatorSession(registry, runtime) {
     const candidates = registry.list().filter((session) => session.role === CODEX_TRANSLATOR_ROLE);
     const live = candidates.find((session) => runtime.getSession(session.id)?.status === "running");
@@ -569,7 +768,7 @@ function compareSessionUpdatedAtDesc(left, right) {
     return (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "");
 }
 function scopeProjectRoleSession(record, taskSlug) {
-    if (!record || record.role !== CODEX_TRANSLATOR_ROLE) {
+    if (!record || (record.role !== CODEX_TRANSLATOR_ROLE && record.role !== GATE_REVIEWER_ROLE)) {
         return record;
     }
     return {
@@ -578,12 +777,31 @@ function scopeProjectRoleSession(record, taskSlug) {
     };
 }
 async function loadPersistedRoleRecordForRole(fs, baseRepoRoot, taskRepoRoot, stateRoot, taskSlug, role) {
+    if (role === GATE_REVIEWER_ROLE) {
+        void taskSlug;
+        return loadPersistedProjectGateReviewerSession(fs, baseRepoRoot);
+    }
     if (role === CODEX_TRANSLATOR_ROLE) {
         void taskSlug;
         return loadPersistedCodexTranslatorSession(fs, baseRepoRoot);
     }
     return loadPersistedRoleRecord(fs, taskRepoRoot, stateRoot, taskSlug, role);
 }
+async function loadPersistedProjectGateReviewerSession(fs, repoRoot) {
+    const sessionPath = resolveRepoPath(repoRoot, GATE_REVIEWER_SESSION_PATH);
+    if (!(await fs.pathExists(sessionPath))) {
+        return undefined;
+    }
+    const payload = await fs.readJson(sessionPath);
+    const record = normalizePersistedRoleRecord(isProjectRoleSessionFile(payload) ? payload.record : payload);
+    if (!record) {
+        return undefined;
+    }
+    return {
+        ...record,
+        taskSlug: PROJECT_GATE_REVIEWER_SCOPE
+    };
+}
 async function loadPersistedCodexTranslatorSession(fs, repoRoot) {
     const sessionPath = resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH);
     if (!(await fs.pathExists(sessionPath))) {
@@ -657,12 +875,27 @@ async function persistTaskSession(fs, repoRoot, stateRoot, session) {
     });
 }
 async function persistRoleSessionRecord(fs, baseRepoRoot, taskRepoRoot, stateRoot, session) {
+    if (session.role === GATE_REVIEWER_ROLE) {
+        await persistProjectGateReviewerSession(fs, baseRepoRoot, session);
+        return;
+    }
     if (session.role === CODEX_TRANSLATOR_ROLE) {
         await persistCodexTranslatorSession(fs, baseRepoRoot, session);
         return;
     }
     await persistTaskSession(fs, taskRepoRoot, stateRoot, session);
 }
+async function persistProjectGateReviewerSession(fs, repoRoot, session) {
+    await fs.writeJsonAtomic(resolveRepoPath(repoRoot, GATE_REVIEWER_SESSION_PATH), {
+        version: 1,
+        role: session.role,
+        updatedAt: session.updatedAt,
+        record: {
+            ...session,
+            taskSlug: PROJECT_GATE_REVIEWER_SCOPE
+        }
+    });
+}
 async function persistCodexTranslatorSession(fs, repoRoot, session) {
     await fs.writeJsonAtomic(resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH), {
         version: 1,
@@ -736,23 +969,6 @@ function normalizeCodexEffort(value) {
     }
     return "default";
 }
-function extractTomlSection(content, sectionName) {
-    const lines = content.split(/\r?\n/);
-    const header = `[${sectionName}]`;
-    const start = lines.findIndex((line) => line.trim() === header);
-    if (start < 0) {
-        return "";
-    }
-    const section = [];
-    for (let index = start + 1; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (/^\s*\[[^\]]+\]\s*$/.test(line)) {
-            break;
-        }
-        section.push(line);
-    }
-    return section.join("\n");
-}
 function parseTomlString(content, key) {
     const pattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"\\s*$`, "m");
     return pattern.exec(content)?.[1];

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

@@ -179,7 +179,7 @@ async function ensureTaskRuntimeStateDirs(fs, taskRepoRoot, stateRoot) {
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "messages"));
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "orchestration"));
     await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "translation"));
-    await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "codex-reviews"));
+    await fs.ensureDir(path.join(taskRepoRoot, stateRoot, "gate-reviews"));
 }
 function getTaskStatePaths(taskStoreRoot, taskRepoRoot, stateRoot, handoffRoot, taskSlug) {
     return [
@@ -188,7 +188,7 @@ function getTaskStatePaths(taskStoreRoot, taskRepoRoot, stateRoot, handoffRoot,
         path.join(taskRepoRoot, stateRoot, "messages", `${taskSlug}.jsonl`),
         path.join(taskRepoRoot, stateRoot, "orchestration", `${taskSlug}.json`),
         path.join(taskRepoRoot, stateRoot, "translation", taskSlug),
-        path.join(taskRepoRoot, stateRoot, "codex-reviews"),
+        path.join(taskRepoRoot, stateRoot, "gate-reviews"),
         path.join(taskRepoRoot, handoffRoot)
     ];
 }

package/dist/backend/templates/harness/claude-root.js

@@ -5,7 +5,7 @@ export function renderRootClaudeHarnessRules() {
 - Read module-local \`CLAUDE.md\` before editing a subdirectory if one exists.
 - Use \`vcm-route-message\` whenever a VCM role hands off work, asks another role a question, reports a result, reports a blocker, or raises a finding. Follow its write-then-stop rule.
 - Use \`vcm-long-running-validation\` for long-running validation. Follow the background job limits below.
-- Project-manager uses \`vcm-codex-review-gate\` at enabled Codex Review Gate trigger points and on VCM Codex review callbacks.
+- Project-manager uses \`vcm-gate-review\` at enabled Gate Review trigger points and on VCM Gate Review callbacks.
 
 ## VCM Background Jobs
 
@@ -32,7 +32,7 @@ export function renderRootClaudeHarnessRules() {
 - Test-only or validation-only work may use: \`project-manager -> reviewer -> project-manager final acceptance\`.
 - If a docs/test/validation-only task reveals required code, architecture, public contract, dependency, durable-doc, or test-strategy changes, route back through the full code-change flow.
 - Keep role outputs under \`.ai/vcm/handoffs/\`.
-- Codex Review Gate reports live under \`.ai/vcm/codex-reviews/\` and are VCM-managed task evidence.
+- Gate Review Gate reports live under \`.ai/vcm/gate-reviews/\` and are VCM-managed task evidence.
 - Runtime task records and handoffs under \`.ai/vcm/\` are temporary. Durable facts must move into code, tests, PR text, commit history, or long-term docs.
 - Record current-task unresolved findings in \`.ai/vcm/handoffs/known-issues.md\`.