vibe-coding-master 0.3.25 → 0.3.27

package/README.md

@@ -11,7 +11,7 @@ VCM is designed for long-running coding work where one Claude Code conversation
 
 Each role runs as a real Claude Code process inside an embedded terminal. The GUI lets the user start, stop, resume, restart, switch, observe, and manually intervene in those sessions without juggling separate terminal windows.
 
-When Codex Review Gates are enabled for a task, or when a Codex Reviewer session already exists, the workspace can also show a fifth `Codex Reviewer` terminal role. It runs Codex CLI from `.ai/codex` with Codex model and effort selectors, receives gate prompts in the same long-lived terminal session, reports hook state back to VCM, and stays outside the normal Claude Code PM routing flow.
+When Gate Review Gates are enabled for a task, or when a Gate Reviewer session already exists, the workspace can also show a fifth `Gate Reviewer` terminal role. It runs Claude Code as a project-scoped long-lived review session, receives short gate prompts that include the current task and worktree path, writes reports under the task worktree, and stays outside normal PM role routing.
 
 ## Current Capabilities
 
@@ -21,7 +21,7 @@ When Codex Review Gates are enabled for a task, or when a Codex Reviewer session
 - Connected repository status for the base repo, including branch, upstream status, commit hash, dirty state, and fast-forward-only pull.
 - Embedded Claude Code terminals powered by `node-pty` and `xterm.js`.
 - One Claude Code session per role, with role tabs in the task header.
-- Optional Codex Reviewer terminal role when any Codex Review Gate is enabled.
+- Optional Gate Reviewer terminal role when any Gate Review Gate is enabled.
 - Role session recovery through persisted Claude session ids and `claude --resume`.
 - Permission mode selection before start, resume, or restart:
   - `default`
@@ -29,7 +29,7 @@ When Codex Review Gates are enabled for a task, or when a Codex Reviewer session
 - PM-mediated role messaging through VCM-dispatched route files.
 - Manual and automatic orchestration modes.
 - Two-stage VCM harness setup: deterministic fixed install plus AI-assisted bootstrap.
-- VCM-managed root rules, four role agents, repo-local VCM skills, Claude Code hooks, Codex Reviewer hooks, generated-context tools, and PR template.
+- VCM-managed root rules, role agents, repo-local VCM skills, Claude Code hooks, generated-context tools, and PR template.
 - Rust generated context for module indexing and crate-external public surface indexing.
 - Translation panel powered by the long-lived Codex Translator session.
 - Mobile Gateway through Tencent iLink Bot API / Weixin DM, for talking to PM and managing tasks from Weixin.
@@ -142,7 +142,7 @@ Important container notes:
 - Make sure the container has network access to Claude services and any configured Codex model endpoints if translation is enabled.
 - VCM accepts normal Git repositories by checking `.git` directly. It also supports `.git` files that point to worktree gitdirs.
 - VCM uses per-command `git -c safe.directory=...` for Git metadata reads and does not require global `git config --global --add safe.directory`.
-- Set `VCM_SANDBOX=devcontainer` so VCM-managed Codex Reviewer and Codex Translator sessions rely on the container boundary and do not start Codex's nested Linux sandbox.
+- Set `VCM_SANDBOX=devcontainer` so VCM-managed Codex Translator sessions rely on the container boundary and do not start Codex's nested Linux sandbox.
 - Treat the container as the sandbox boundary, especially when using relaxed Claude Code permission modes.
 
 ## Basic Usage
@@ -390,7 +390,7 @@ Translation settings are local and stored in:
 
 The same file stores recent repository paths and global translation preferences such as enablement, auto-send, and target language.
 
-VCM resolves `vcmDataDir` from `VCM_DATA_DIR`. If `VCM_DATA_DIR` is unset or empty, VCM uses `~/.vcm`. In Dev Containers, set `VCM_DATA_DIR=/workspace/.ai/vcm` and `VCM_SANDBOX=devcontainer` through `containerEnv` so VCM app state survives container rebuilds and VCM-managed Codex Reviewer and Codex Translator sessions do not run a nested Codex sandbox.
+VCM resolves `vcmDataDir` from `VCM_DATA_DIR`. If `VCM_DATA_DIR` is unset or empty, VCM uses `~/.vcm`. In Dev Containers, set `VCM_DATA_DIR=/workspace/.ai/vcm` and `VCM_SANDBOX=devcontainer` through `containerEnv` so VCM app state survives container rebuilds and VCM-managed Codex Translator sessions do not run a nested Codex sandbox.
 
 The sidebar `Settings` section also stores the UI theme preference in this file. The default is `system`, which follows the OS/browser color-scheme preference; users can cycle between `System`, `Light`, and `Dark`.
 
@@ -485,7 +485,7 @@ For `.gitignore`, VCM uses a gitignore-native managed block:
 
 `.ai/vcm/` is the active VCM local control area, and `.claude/worktrees/` is the Claude-compatible task worktree area. VCM keeps the task index in app-local project state under `<vcmDataDir>/projects/`; each task runtime repo keeps its own session, message, orchestration, and translation state.
 
-VCM also JSON-merges `.claude/settings.json` to install Claude Code `PreToolUse`, `UserPromptSubmit`, `Stop`, and `PermissionRequest` hooks plus a managed `env.BASH_DEFAULT_TIMEOUT_MS` so foreground watch windows fit inside the Bash tool timeout. The hooks post directly to the local VCM backend, so roles do not need a VCM CLI command to confirm delivery or report turn completion. The `Stop` hook forwards the backend response to Claude Code, which lets VCM block turn-end while a validation job is still running. When Codex Review Gates are installed, VCM also writes `.ai/codex/.codex/config.toml` and `.ai/codex/.codex/hooks.json` so the embedded Codex Reviewer terminal can POST `UserPromptSubmit` and `Stop` events back to VCM.
+VCM also JSON-merges `.claude/settings.json` to install Claude Code `PreToolUse`, `UserPromptSubmit`, `Stop`, and `PermissionRequest` hooks plus a managed `env.BASH_DEFAULT_TIMEOUT_MS` so foreground watch windows fit inside the Bash tool timeout. The hooks post directly to the local VCM backend, so roles do not need a VCM CLI command to confirm delivery or report turn completion. The `Stop` hook forwards the backend response to Claude Code, which lets VCM block turn-end while a validation job is still running.
 
 Bootstrap is AI-assisted. VCM starts a visible temporary Claude Code session in the connected repository and asks it to use the `vcm-harness-bootstrap` skill. Bootstrap fills project-specific content and generated context:
 
@@ -572,7 +572,7 @@ When it is on, VCM is in auto mode:
 - When the target role later reaches `Stop`, VCM scans again and may deliver the next pending route file.
 - If auto orchestration gets stuck after a manual copy/paste recovery, `Mark All Done` clears pending route files. It does not mutate message history.
 
-VCM Harness injects Claude Code `UserPromptSubmit` and `Stop` hooks into `.claude/settings.json`, and Codex Reviewer hooks into `.ai/codex/.codex/hooks.json`. Role tabs become `running` when Claude Code or Codex accepts a prompt and `idle` after `Stop`; VCM also marks a role `running` immediately after it writes a message to that embedded terminal. The terminal process status is still tracked separately. Claude role rules require a role to end its turn after writing or updating a message route file, rather than polling, looping, or waiting for another role inside the same Claude Code turn; Codex Reviewer does not dispatch route files.
+VCM Harness injects Claude Code `UserPromptSubmit` and `Stop` hooks into `.claude/settings.json`. Role tabs become `running` when Claude Code accepts a prompt and `idle` after `Stop`; VCM also marks a role `running` immediately after it writes a message to that embedded terminal. Gate Reviewer is a Claude Code role, but VCM triggers and settles gate turns directly around the gate prompt and report callback. The terminal process status is still tracked separately. Claude role rules require a role to end its turn after writing or updating a message route file, rather than polling, looping, or waiting for another role inside the same Claude Code turn.
 
 The implementation keeps only the active manual/auto orchestration mode. It does not expose pause/resume, stage/approve/reject, or a separate agent-facing message CLI.
 

package/dist/backend/api/codex-hook-routes.js

@@ -1,11 +1,4 @@
 export function registerCodexHookRoutes(app, deps) {
-    app.post("/api/hooks/codex-reviewer", async (request) => {
-        return deps.codexHookService.handleHook(request.body);
-    });
-    app.post("/api/hooks/codex-reviewer/stop", async (request) => {
-        await deps.codexHookService.handleStopHook(request.body);
-        return {};
-    });
     app.post("/api/hooks/codex-translator", async (request) => {
         return deps.codexHookService.handleHook(request.body);
     });

package/dist/backend/api/gate-review-routes.js

@@ -0,0 +1,58 @@
+import { VcmError } from "../errors.js";
+import { isGateReviewGate } from "../services/gate-review-service.js";
+export function registerGateReviewRoutes(app, deps) {
+    app.get("/api/tasks/:taskSlug/gate-review", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.gateReviewService.getState(project.repoRoot, request.params.taskSlug);
+    });
+    app.put("/api/tasks/:taskSlug/gate-review/settings", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.gateReviewService.updateSettings(project.repoRoot, request.params.taskSlug, request.body);
+    });
+    app.post("/api/tasks/:taskSlug/gate-review/:gate/request", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const gate = parseGate(request.params.gate);
+        return deps.gateReviewService.requestReviewGate(project.repoRoot, request.params.taskSlug, gate);
+    });
+    app.post("/api/tasks/:taskSlug/gate-review/:gate/retry", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const gate = parseGate(request.params.gate);
+        return deps.gateReviewService.retryReviewGate(project.repoRoot, request.params.taskSlug, gate);
+    });
+    app.post("/api/tasks/:taskSlug/gate-review/:gate/skip", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const gate = parseGate(request.params.gate);
+        return deps.gateReviewService.skipReviewGate(project.repoRoot, request.params.taskSlug, gate, request.body);
+    });
+    app.post("/api/tasks/:taskSlug/gate-review/:gate/override", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const gate = parseGate(request.params.gate);
+        return deps.gateReviewService.overrideReviewGate(project.repoRoot, request.params.taskSlug, gate, request.body);
+    });
+    app.get("/api/tasks/:taskSlug/gate-review/:gate/report", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const gate = parseGate(request.params.gate);
+        return deps.gateReviewService.readReport(project.repoRoot, request.params.taskSlug, gate);
+    });
+}
+function parseGate(gate) {
+    if (!isGateReviewGate(gate)) {
+        throw new VcmError({
+            code: "UNKNOWN_GATE_REVIEW_GATE",
+            message: `Unknown Gate review gate: ${gate}`,
+            statusCode: 400
+        });
+    }
+    return gate;
+}
+async function requireCurrentProject(projectService) {
+    const project = await projectService.getCurrentProject();
+    if (!project) {
+        throw new VcmError({
+            code: "PROJECT_NOT_CONNECTED",
+            message: "Connect a repository first.",
+            statusCode: 409
+        });
+    }
+    return project;
+}

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

@@ -1,4 +1,4 @@
-import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES, isVcmRoleName } from "../../shared/constants.js";
 import { isOpenFileLimitError, VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerTaskRoutes(app, deps) {
@@ -40,7 +40,7 @@ export function registerTaskRoutes(app, deps) {
 async function stopRunningRoleSessions(deps, repoRoot, taskSlug) {
     const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
     for (const session of sessions) {
-        if (session.status === "running") {
+        if (session.status === "running" && isVcmRoleName(session.role)) {
             await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
         }
     }

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

@@ -6,7 +6,7 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 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";
@@ -31,6 +31,8 @@ const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
+    { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];
 const AGENT_FRONTMATTER = {
@@ -45,6 +47,9 @@ const AGENT_FRONTMATTER = {
     },
     reviewer: {
         description: "VCM independent review role for acceptance, test adequacy, scope checks, and risk findings."
+    },
+    "gate-reviewer": {
+        description: "VCM independent gate review role for architecture plans, validation adequacy, and final diffs."
     }
 };
 const MANAGED_FILES = [
@@ -104,11 +109,12 @@ const MANAGED_FILES = [
         content: renderPullRequestTemplateHarnessRules()
     },
     {
-        path: ".ai/codex/AGENTS.md",
-        title: "VCM Codex Reviewer",
+        path: ".claude/agents/gate-reviewer.md",
+        title: "Gate Reviewer Agent",
+        agentName: "gate-reviewer",
         commentStyle: "html",
-        category: "codex-reviewer-agent",
-        content: renderCodexAgentsHarnessRules()
+        category: "gate-reviewer-agent",
+        content: renderGateReviewerAgentRules()
     },
     {
         path: ".ai/codex-translator/AGENTS.md",
@@ -170,28 +176,10 @@ const WHOLE_FILES = [
         content: renderSkillFile("VCM Route Message Skill", "vcm-route-message", "Use when a VCM role needs to hand off work, ask a question, report a result, report a blocker, or raise a finding to another VCM role.", renderVcmRouteMessageSkillRules())
     },
     {
-        path: ".claude/skills/vcm-codex-review-gate/SKILL.md",
+        path: ".claude/skills/vcm-gate-review/SKILL.md",
         category: "skill",
         mode: 0o644,
-        content: renderSkillFile("VCM Codex Review Gate Skill", "vcm-codex-review-gate", "Use when project-manager reaches a Codex Review Gate or receives a VCM Codex Review callback.", renderVcmCodexReviewGateSkillRules())
-    },
-    {
-        path: ".ai/codex/config.toml",
-        category: "codex-review-config",
-        mode: 0o644,
-        content: renderCodexConfigHarnessRules()
-    },
-    {
-        path: ".ai/codex/.codex/config.toml",
-        category: "codex-review-hooks",
-        mode: 0o644,
-        content: renderCodexCliConfigHarnessRules()
-    },
-    {
-        path: ".ai/codex/.codex/hooks.json",
-        category: "codex-review-hooks",
-        mode: 0o644,
-        content: renderCodexHooksHarnessRules()
+        content: renderSkillFile("VCM Gate Review Skill", "vcm-gate-review", "Use when project-manager reaches a Gate Review trigger or receives a VCM Gate Review callback.", renderVcmGateReviewSkillRules())
     },
     {
         path: ".ai/codex-translator/config.toml",
@@ -212,34 +200,10 @@ const WHOLE_FILES = [
         content: renderCodexHooksHarnessRules("codex-translator")
     },
     {
-        path: ".ai/codex/prompts/architecture-plan-gate.md",
-        category: "codex-review-prompt",
-        mode: 0o644,
-        content: renderCodexArchitecturePlanPrompt()
-    },
-    {
-        path: ".ai/codex/prompts/validation-adequacy-gate.md",
-        category: "codex-review-prompt",
-        mode: 0o644,
-        content: renderCodexValidationAdequacyPrompt()
-    },
-    {
-        path: ".ai/codex/prompts/final-diff-gate.md",
-        category: "codex-review-prompt",
-        mode: 0o644,
-        content: renderCodexFinalDiffPrompt()
-    },
-    {
-        path: ".ai/codex/schemas/codex-review-result.schema.json",
-        category: "codex-review-schema",
-        mode: 0o644,
-        content: renderCodexReviewResultSchema()
-    },
-    {
-        path: ".ai/tools/request-codex-review",
+        path: ".ai/tools/request-gate-review",
         category: "runtime-tool",
         mode: 0o755,
-        content: renderRequestCodexReviewTool()
+        content: renderRequestGateReviewTool()
     },
     {
         path: ".ai/tools/run-long-check",
@@ -452,15 +416,11 @@ function fixedDirectories() {
         ".claude/skills/vcm-harness-bootstrap/",
         ".claude/skills/vcm-long-running-validation/",
         ".claude/skills/vcm-route-message/",
-        ".claude/skills/vcm-codex-review-gate/",
-        ".ai/codex/",
-        ".ai/codex/.codex/",
-        ".ai/codex/prompts/",
-        ".ai/codex/schemas/",
+        ".claude/skills/vcm-gate-review/",
         ".ai/codex-translator/",
         ".ai/codex-translator/.codex/",
         ".ai/vcm/translations/",
-        ".ai/vcm/codex-reviews/",
+        ".ai/vcm/gate-reviews/",
         ".ai/tools/",
         ".ai/generated/"
     ];

package/dist/backend/server.js

@@ -11,7 +11,7 @@ import { createCodexHookService } from "./services/codex-hook-service.js";
 import { createGitAdapter } from "./adapters/git-adapter.js";
 import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
-import { createCodexReviewService } from "./services/codex-review-service.js";
+import { createGateReviewService } from "./services/gate-review-service.js";
 import { createCodexTranslationService } from "./services/codex-translation-service.js";
 import { createHarnessService, createScriptFixedHarnessInstaller } from "./services/harness-service.js";
 import { createNodeFileSystemAdapter } from "./adapters/filesystem.js";
@@ -37,7 +37,7 @@ import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
 import { registerArtifactRoutes } from "./api/artifact-routes.js";
 import { registerClaudeHookRoutes } from "./api/claude-hook-routes.js";
 import { registerCodexHookRoutes } from "./api/codex-hook-routes.js";
-import { registerCodexReviewRoutes } from "./api/codex-review-routes.js";
+import { registerGateReviewRoutes } from "./api/gate-review-routes.js";
 import { registerCodexTranslationRoutes } from "./api/codex-translation-routes.js";
 import { registerHarnessRoutes } from "./api/harness-routes.js";
 import { registerMessageRoutes } from "./api/message-routes.js";
@@ -67,9 +67,9 @@ export async function createServer(deps, options = {}) {
     registerAppSettingsRoutes(app, { appSettings: deps.appSettings });
     registerClaudeHookRoutes(app, { claudeHookService: deps.claudeHookService });
     registerCodexHookRoutes(app, { codexHookService: deps.codexHookService });
-    registerCodexReviewRoutes(app, {
+    registerGateReviewRoutes(app, {
         projectService: deps.projectService,
-        codexReviewService: deps.codexReviewService
+        gateReviewService: deps.gateReviewService
     });
     registerCodexTranslationRoutes(app, {
         projectService: deps.projectService,
@@ -213,7 +213,7 @@ export function createDefaultServerDeps(options = {}) {
             await taskService.updateTaskStatus(repoRoot, taskSlug, status);
         }
     });
-    const codexReviewService = createCodexReviewService({
+    const gateReviewService = createGateReviewService({
         fs,
         runner,
         runtime,
@@ -266,14 +266,13 @@ export function createDefaultServerDeps(options = {}) {
         roundService,
         translationService,
         appSettings,
+        runtime,
         gatewayService,
         jobGuard: createJobGuardService()
     });
     const codexHookService = createCodexHookService({
         projectService,
-        taskService,
         sessionService,
-        roundService,
         codexTranslationService
     });
     const diagnosticsService = createDiagnosticsService({
@@ -293,7 +292,7 @@ export function createDefaultServerDeps(options = {}) {
         claudeHookService,
         codexHookService,
         messageService,
-        codexReviewService,
+        gateReviewService,
         codexTranslationService,
         roundService,
         statusService,

package/dist/backend/services/app-settings-service.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
-import { CODEX_REVIEW_GATES } from "../../shared/types/codex-review.js";
+import { GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
 import { createDefaultLaunchTemplate, DEFAULT_TRANSLATION_OUTPUT_MODE, DEFAULT_TRANSLATION_TARGET_LANGUAGE, TRANSLATION_OUTPUT_MODE_OPTIONS, TRANSLATION_TARGET_LANGUAGE_OPTIONS } from "../../shared/types/app-settings.js";
 import { CLAUDE_MODEL_OPTIONS, SESSION_EFFORT_OPTIONS } from "../../shared/types/session.js";
 import { resolveVcmDataDir } from "../vcm-data-dir.js";
@@ -118,26 +118,26 @@ export function createAppSettingsService(deps) {
             });
             return config;
         },
-        async getCodexReviewSettings() {
+        async getGateReviewSettings() {
             const settings = await loadSettings();
-            const requiredGates = normalizeCodexReviewGates(settings.codexReview?.requiredGates);
+            const requiredGates = normalizeGateReviewGates(settings.gateReview?.requiredGates);
             return {
                 enabled: requiredGates.length > 0,
                 requiredGates
             };
         },
-        async updateCodexReviewSettings(_repoRoot, _taskSlug, requiredGates) {
+        async updateGateReviewSettings(_repoRoot, _taskSlug, requiredGates) {
             const current = await loadSettings();
-            const normalizedRequiredGates = normalizeCodexReviewGates(requiredGates);
+            const normalizedRequiredGates = normalizeGateReviewGates(requiredGates);
             const timestamp = new Date().toISOString();
-            const nextCodexReview = {
+            const nextGateReview = {
                 version: 1,
                 requiredGates: normalizedRequiredGates,
                 updatedAt: timestamp
             };
             await saveSettings({
                 ...current,
-                codexReview: normalizeCodexReviewSettingsState(nextCodexReview)
+                gateReview: normalizeGateReviewSettingsState(nextGateReview)
             });
             return {
                 enabled: normalizedRequiredGates.length > 0,
@@ -187,28 +187,28 @@ function normalizeProjectIndexFile(input) {
         projects
     };
 }
-function normalizeCodexReviewSettingsState(input) {
+function normalizeGateReviewSettingsState(input) {
     if (!isObject(input)) {
         return undefined;
     }
     return {
         version: 1,
-        requiredGates: normalizeCodexReviewGates(input.requiredGates),
+        requiredGates: normalizeGateReviewGates(input.requiredGates),
         updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : new Date(0).toISOString()
     };
 }
-function normalizeCodexReviewGates(input) {
+function normalizeGateReviewGates(input) {
     if (!Array.isArray(input)) {
         return [];
     }
     const gates = [];
     for (const value of input) {
-        if (!CODEX_REVIEW_GATES.includes(value) || gates.includes(value)) {
+        if (!GATE_REVIEW_GATES.includes(value) || gates.includes(value)) {
             continue;
         }
         gates.push(value);
     }
-    return CODEX_REVIEW_GATES.filter((gate) => gates.includes(gate));
+    return GATE_REVIEW_GATES.filter((gate) => gates.includes(gate));
 }
 function normalizeSettingsFile(input) {
     const settings = {
@@ -216,9 +216,9 @@ function normalizeSettingsFile(input) {
         preferences: normalizePreferences(input.preferences),
         recentRepositoryPaths: normalizeRecentRepositoryPaths(input.recentRepositoryPaths)
     };
-    const codexReview = normalizeCodexReviewSettingsState(input.codexReview);
-    if (codexReview) {
-        settings.codexReview = codexReview;
+    const gateReview = normalizeGateReviewSettingsState(input.gateReview);
+    if (gateReview) {
+        settings.gateReview = gateReview;
     }
     return settings;
 }