vibe-coding-master 0.3.26 → 0.3.28

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,11 +29,11 @@ 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.
-- Durable task state, session state, raw terminal logs, handoff artifacts, and message history.
+- Durable task state, role session state, handoff artifacts, and message history.
 
 ## Requirements
 
@@ -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
@@ -193,14 +193,12 @@ In this terminology, `Session` is a VCM statistics term. It is different from a
 
 ## Task Worktree Management
 
-VCM uses task-level worktree management by default:
+VCM uses task-level worktree management for every task:
 
 ```text
 one task = one branch + one git worktree + one handoff directory + one role-session set
 ```
 
-The `Create worktree and branch` option is selected by default when creating a task:
-
 - task name: `<task>`
 - branch: `feature/<task>`
 - worktree path: `.claude/worktrees/<task>` inside the connected base repository
@@ -208,13 +206,11 @@ The `Create worktree and branch` option is selected by default when creating a t
 
 VCM will not create worktrees per role. `project-manager`, `architect`, `coder`, and `reviewer` for the same task share the same task worktree.
 
-The user can turn this option off. In that mode, VCM creates app-local task metadata, creates the handoff structure in the connected repository, records the current branch, and starts role sessions from the connected repository path.
-
 VCM will not offer a separate `Create task worktree` button after a task exists, and a task should not be switched to another branch/worktree mode after creation.
 
 Because worktrees live under `.claude/worktrees/`, the connected repository must ignore both `.ai/vcm/` and `.claude/worktrees/`. Apply the VCM Harness before creating tasks so `.gitignore` contains the managed ignore block. The base repository must also be clean because the task branch/worktree is created from the connected repo's current `HEAD`.
 
-When a task is complete, VCM provides a red `Close Task` action. Closing a task shows a destructive confirmation, stops VCM-managed running role sessions for that task, then deletes the task worktree, deletes the task branch by default, removes the app-local task record, and removes task runtime metadata. VCM does not preflight running sessions or uncommitted changes before closing. Tasks created without a worktree only remove VCM metadata because they do not own a separate branch/worktree.
+When a task is complete, VCM provides a red `Close Task` action. Closing a task shows a destructive confirmation, stops VCM-managed running role sessions for that task, then deletes the task worktree, deletes the task branch by default, removes the app-local task record, and removes task runtime metadata. VCM does not preflight running sessions or uncommitted changes before closing. Project-scoped Gate Reviewer and Codex Translator sessions are not task-owned and are not stopped by Close Task.
 
 ## Sidebar UI
 
@@ -223,6 +219,8 @@ The left sidebar is intentionally compact and collapsible:
 - `Repository Path`: path input on one row; `Recent` and `Connect` on the next row.
 - `Connected Repository`: connected base repo path, branch, upstream/ahead-behind status, commit hash, working tree state, and a `Pull` button.
 - `Settings`: `Theme`, `Flow pause alert`, `Try alert`, `Messages`, and `Events`.
+- `Translation`: global conversation translation, auto-send, target language, output scope, file translation, bootstrap, memory update, session status, and Codex Translator session access.
+- `Gate Review Gates`: global gate switches for architecture plan, validation adequacy, and final diff.
 - `Gateway`: Weixin iLink binding, Gateway on/off, Gateway translation, and QR login.
 - `VCM Harness`: fixed-install status, bootstrap completion checks, and the bootstrap terminal when one is running.
 - `New Task`: one `task name` input.
@@ -233,9 +231,8 @@ All sidebar sections are collapsed by default. When no task is selected, `Reposi
 Opening `Connected Repository` refreshes the base repo status through the
 backend. VCM does not poll it continuously. The `Pull` button runs
 `git pull --ff-only` against the connected base repo only. It is disabled when
-the base repo has uncommitted changes, when the current branch has no upstream,
-or when the active task is an inline task using the base repo directly. It does
-not stash, merge, or mutate task worktrees.
+the base repo has uncommitted changes or when the current branch has no
+upstream. It does not stash, merge, or mutate task worktrees.
 
 When VCM is connected to an active task, the bottom of the sidebar shows a task status dock. It stays outside the collapsible groups and shows the active VCM Session title, task status, start time, total elapsed time, total Round count, and role active runtime. The dock also shows the Current Round while it is running, or the Last Round after a flow pause, including start time, total elapsed time, role active runtime, Turn count, and Round status.
 
@@ -360,7 +357,7 @@ Typical mobile flow:
 
 `/pull-current` only pulls the connected base repository. It does not pull task worktrees, stash local changes, merge divergent branches, or run arbitrary shell commands.
 
-`/create-task` uses the saved launch template from the desktop settings. The template controls permission mode, model, effort, auto orchestration, and translation defaults for the four role sessions.
+`/create-task` uses the saved launch template from the desktop settings. The template controls permission mode, model, effort, and auto orchestration for the four core role sessions. Gateway translation uses the global Gateway translation setting, not the launch template.
 
 `/close-task` is destructive. It stops VCM-managed role sessions and removes task-owned worktree/branch state according to the same cleanup behavior as the desktop `Close Task` action.
 
@@ -378,7 +375,7 @@ Typical mobile flow:
 
 ## Translation
 
-The task header has a global `Translate` button next to `Close Task`. It opens a translation panel beside the embedded terminal for the role consoles and keeps the same on/off setting while switching roles. The terminal and translation panel split the available width evenly.
+Translation is controlled from the sidebar `Translation` group. When conversation translation is enabled, each running core VCM role console shows a translation panel beside the embedded terminal. The terminal and translation panel split the available width evenly.
 
 The task header does not include a manual `Refresh` button. Task status, role status, messages, orchestration state, and flow pause state refresh automatically. The remaining `Refresh` button lives only in the sidebar `VCM Harness` section and is for rechecking harness files.
 
@@ -390,7 +387,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`.
 
@@ -401,7 +398,7 @@ When Gateway is on, `Flow pause alert` is forced off because mobile notification
 Translation behavior:
 
 - Conversation translation is routed through the Codex Translator session and result files.
-- Global translation controls live in the sidebar Translation section: enablement, auto-send, target language, bootstrap, memory update, and file translation.
+- Global translation controls live in the sidebar Translation section: enablement, auto-send, target language, output scope, bootstrap, memory update, file translation, session status, and `Open Session`.
 - File and conversation translation share `<baseRepoRoot>/.ai/vcm/translations/`; conversation result files are temporary runtime artifacts.
 - Claude Code output translation reads semantic Claude transcript JSONL files under `~/.claude/projects`, not raw PTY output.
 - Claude Code prose output waits 10 seconds before dispatch so adjacent output can be translated in one Codex batch.
@@ -415,10 +412,10 @@ Translation behavior:
 - Assistant prose renders Markdown in the panel, including headings, lists, code fences, tables, and links.
 - Tool calls and tool results are preserved as dim one-line rows such as `● Bash({"command":"npm test"})`.
 - User input uses one textarea. Press `Enter` to translate or send the current English draft; press `Shift+Enter` for a newline.
-- After user input is translated, the translated draft is appended after the original text in the same textarea.
+- After user input is translated, the English draft is appended after the original source text in the same textarea.
 - `Send English` writes the current English draft to the active embedded terminal and submits it.
 - Automatic terminal submission uses bracketed paste first, then sends Enter separately for Claude Code TUI reliability.
-- The translation panel `Auto-send` toggle sends the translated draft automatically when translation succeeds without warnings.
+- The sidebar `Auto-send` toggle sends the translated draft automatically when translation succeeds without warnings.
 
 ## Project Harness
 
@@ -438,7 +435,13 @@ CLAUDE.md
 .claude/skills/vcm-final-acceptance/SKILL.md
 .claude/skills/vcm-long-running-validation/SKILL.md
 .claude/skills/vcm-harness-bootstrap/SKILL.md
-.ai/vcm-harness-manifest.json
+.claude/skills/vcm-gate-review/SKILL.md
+.claude/agents/gate-reviewer.md
+.ai/codex-translator/AGENTS.md
+.ai/codex-translator/config.toml
+.ai/codex-translator/.codex/config.toml
+.ai/codex-translator/.codex/hooks.json
+.ai/tools/request-gate-review
 .ai/tools/generate-module-index
 .ai/tools/generate-public-surface
 .ai/tools/run-long-check
@@ -485,7 +488,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:
 
@@ -536,7 +539,6 @@ Runtime message and handoff files:
 .ai/vcm/messages/<task>.jsonl                 # under the task runtime repo
 .ai/vcm/orchestration/<task>.json             # under the task runtime repo
 .ai/vcm/handoffs/messages/<from-role>-<to-role>.md
-.ai/vcm/handoffs/logs/
 ```
 
 Each directed role route has exactly one message file. Route messages are the only dynamic task-dispatch files. If a role changes its mind during one turn, it edits the same route file instead of creating another message. A blank file means no pending message; a non-empty file means pending work for VCM to submit.
@@ -572,7 +574,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.
 
@@ -603,7 +605,7 @@ Session buttons behave as follows:
 - `Restart`: stops the current process if needed, creates a new UUID, and starts a fresh Claude session.
 - `Stop`: stops the embedded terminal process and leaves the persisted Claude session id resumable.
 
-Embedded terminal output is still written to raw role log files under `.ai/vcm/handoffs/logs/`. When a browser reconnects to a running terminal, VCM replays only the tail of that log, capped at 2 MB, rather than streaming the entire historical log back into xterm. This keeps long sessions responsive while preserving full logs on disk until task cleanup.
+Ordinary VCM role sessions do not persist raw terminal logs under handoff state. Claude Code transcript JSONL files under `~/.claude/projects/` are the semantic record used for output translation and recovery.
 
 ## Local Project Files
 
@@ -622,7 +624,9 @@ For a connected repository, VCM uses:
 <taskRepoRoot>/.ai/vcm/handoffs/review-report.md
 <taskRepoRoot>/.ai/vcm/handoffs/docs-sync-report.md
 <taskRepoRoot>/.ai/vcm/handoffs/messages/<from-role>-<to-role>.md
-<taskRepoRoot>/.ai/vcm/handoffs/logs/{project-manager,architect,coder,reviewer}.log
+<taskRepoRoot>/.ai/vcm/gate-reviews/
+<baseRepoRoot>/.ai/vcm/gate-reviewer/session.json
+<baseRepoRoot>/.ai/vcm/translations/
 ```
 
 The project config is stored under `vcmDataDir` so it is durable local app state. `vcmDataDir` is `VCM_DATA_DIR` when set, otherwise `~/.vcm`. For Dev Containers, prefer:
@@ -635,9 +639,7 @@ The project config is stored under `vcmDataDir` so it is durable local app state
 }
 ```
 
-For worktree-backed tasks, `taskRepoRoot` is `<baseRepoRoot>/.claude/worktrees/<task>`; for inline tasks, `taskRepoRoot` is the connected base repo.
-
-Because handoffs are scoped to `taskRepoRoot` without an extra task-name directory, VCM allows only one active inline task per connected repository. Use the default worktree mode for parallel tasks.
+For every task, `taskRepoRoot` is `<baseRepoRoot>/.claude/worktrees/<task>`.
 
 ## Packaging
 
@@ -680,4 +682,6 @@ See also:
 - `docs/v0.2-implementation-plan.md`
 - `docs/vcm-cc-best-practices.md`
 - `docs/full-harness-baseline.md`
+- `docs/gate-review-gates.md`
+- `docs/codex-translation-plan.md`
 - `docs/cc-best-practices.md` is archived and no longer maintained.

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";
@@ -47,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 = [
@@ -106,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",
@@ -172,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",
@@ -214,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",
@@ -454,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,
@@ -272,9 +272,7 @@ export function createDefaultServerDeps(options = {}) {
     });
     const codexHookService = createCodexHookService({
         projectService,
-        taskService,
         sessionService,
-        roundService,
         codexTranslationService
     });
     const diagnosticsService = createDiagnosticsService({
@@ -294,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;
 }