vibe-coding-master 0.3.28 → 0.3.30

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 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.
+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 is an optional VCM flow role powered by Claude Code. Its session is project-scoped and reusable across tasks, but each gate turn is bound to the current task/worktree, writes reports under the task worktree, and stays outside normal PM route-file dispatch.
 
 ## Current Capabilities
 
@@ -21,7 +21,7 @@ When Gate Review Gates are enabled for a task, or when a Gate Reviewer session a
 - 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 Gate Reviewer terminal role when any Gate Review Gate is enabled.
+- Optional Gate Reviewer VCM flow 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`
@@ -31,7 +31,7 @@ When Gate Review Gates are enabled for a task, or when a Gate Reviewer session a
 - Two-stage VCM harness setup: deterministic fixed install plus AI-assisted bootstrap.
 - 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.
+- Translation panel powered by the long-lived Translator session.
 - Mobile Gateway through Tencent iLink Bot API / Weixin DM, for talking to PM and managing tasks from Weixin.
 - Durable task state, role session state, handoff artifacts, and message history.
 
@@ -139,10 +139,9 @@ Important container notes:
 
 - Install Claude Code inside the container, or make `claude` available in the container `PATH`.
 - Make sure Claude Code authentication works inside the container.
-- Make sure the container has network access to Claude services and any configured Codex model endpoints if translation is enabled.
+- Make sure the container has network access to Claude services 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 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
@@ -210,7 +209,7 @@ VCM will not offer a separate `Create task worktree` button after a task exists,
 
 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. Project-scoped Gate Reviewer and Codex Translator sessions are not task-owned and are not stopped by Close Task.
+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 Translator sessions are not task-owned and are not stopped by Close Task.
 
 ## Sidebar UI
 
@@ -219,7 +218,7 @@ 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.
+- `Translation`: global conversation translation, auto-send, target language, output scope, file translation, bootstrap, memory update, session status, and 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.
@@ -350,14 +349,14 @@ Typical mobile flow:
 - `/pull-current`: runs the same fast-forward-only connected repository pull as the desktop `Pull` button.
 - `/tasks`: lists tasks for the selected project.
 - `/use-task <index-or-task-slug>`: selects the Gateway's current task context.
-- `/create-task <task-slug> [title]`: creates a worktree-backed task and starts the four role sessions using the saved launch template.
+- `/create-task <task-slug> [title]`: creates a worktree-backed task and starts the four core role sessions using the saved launch template. If any Gate Review Gate is enabled, Gateway also resumes or starts Gate Reviewer from the saved template.
 - `/close-task`: starts a destructive close confirmation for the current task.
 - `/close-task confirm <task-slug>`: closes the task through VCM cleanup after exact slug confirmation.
 - `/translate on` and `/translate off`: changes Gateway translation for mobile messages.
 
 `/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, and auto orchestration for the four core role sessions. Gateway translation uses the global Gateway translation setting, not the launch template.
+`/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 plus the optional Gate Reviewer. 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.
 
@@ -387,7 +386,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 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` through `containerEnv` so VCM app state survives container rebuilds.
 
 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`.
 
@@ -397,11 +396,11 @@ 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.
+- Conversation translation is routed through the Translator session and result files.
 - 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.
+- Claude Code prose output waits 10 seconds before dispatch so adjacent output can be translated in one Claude Code Translator batch.
 - VCM tails those transcript files in the backend. Closing the translation panel does not stop capture; the tailer stops only when the role session is stopped/restarted or the task is closed.
 - Translation events are cached under the task runtime repo at `.ai/vcm/translation/<task>/<role>/<session-id>.jsonl` and delivered to the frontend through HTTP polling.
 - The polling cursor is the next expected seq: `after=18` acknowledges seq `1..17` and returns seq `18+`; there is no snapshot mismatch error.
@@ -437,10 +436,7 @@ CLAUDE.md
 .claude/skills/vcm-harness-bootstrap/SKILL.md
 .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
+.claude/agents/translator.md
 .ai/tools/request-gate-review
 .ai/tools/generate-module-index
 .ai/tools/generate-public-surface
@@ -574,7 +570,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`. 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.
+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 uses the same Claude hook/Round/translation path as other VCM flow roles, while VCM still owns gate report polling and the PM callback. The terminal process status is 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.
 
@@ -683,5 +679,5 @@ See also:
 - `docs/vcm-cc-best-practices.md`
 - `docs/full-harness-baseline.md`
 - `docs/gate-review-gates.md`
-- `docs/codex-translation-plan.md`
+- `docs/claude-code-translation-plan.md`
 - `docs/cc-best-practices.md` is archived and no longer maintained.

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

@@ -5,7 +5,7 @@ export function registerProjectRoutes(app, deps) {
     });
     app.post("/api/projects/connect", async (request) => {
         const project = await deps.projectService.connectProject(request.body);
-        await deps.codexTranslationService?.cleanupStartupRuntime(project.repoRoot);
+        await deps.translationWorkerService?.cleanupStartupRuntime(project.repoRoot);
         return project;
     });
     app.get("/api/projects/current", async () => {

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

@@ -1,4 +1,4 @@
-import { DISPATCHABLE_ROLES, isVcmRoleName } from "../../shared/constants.js";
+import { CORE_VCM_ROLE_NAMES, DISPATCHABLE_ROLES } 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" && isVcmRoleName(session.role)) {
+        if (session.status === "running" && CORE_VCM_ROLE_NAMES.some((role) => role === session.role)) {
             await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
         }
     }

package/dist/backend/api/{codex-translation-routes.js → translation-worker-routes.js}

@@ -1,60 +1,60 @@
 import { VcmError } from "../errors.js";
-export function registerCodexTranslationRoutes(app, deps) {
-    app.get("/api/translation/codex/state", async () => {
+export function registerTranslationWorkerRoutes(app, deps) {
+    app.get("/api/translation/state", async () => {
         const project = await requireCurrentProject(deps.projectService);
-        return deps.codexTranslationService.getState(project.repoRoot, {
+        return deps.translationWorkerService.getState(project.repoRoot, {
             visibility: "public"
         });
     });
-    app.get("/api/translation/codex/session", async () => {
+    app.get("/api/translation/session", async () => {
         const project = await requireCurrentProject(deps.projectService);
         return (await deps.sessionService.getProjectTranslatorSession(project.repoRoot)) ?? null;
     });
-    app.post("/api/translation/codex/session/ensure", async (request) => {
+    app.post("/api/translation/session/ensure", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         return deps.sessionService.ensureProjectTranslatorSession(project.repoRoot, request.body);
     });
-    app.post("/api/translation/codex/session/start", async (request) => {
+    app.post("/api/translation/session/start", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         return deps.sessionService.startProjectTranslatorSession(project.repoRoot, request.body);
     });
-    app.post("/api/translation/codex/session/resume", async (request) => {
+    app.post("/api/translation/session/resume", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         return deps.sessionService.resumeProjectTranslatorSession(project.repoRoot, request.body);
     });
-    app.post("/api/translation/codex/session/restart", async (request) => {
+    app.post("/api/translation/session/restart", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         return deps.sessionService.restartProjectTranslatorSession(project.repoRoot, request.body);
     });
-    app.post("/api/translation/codex/session/stop", async () => {
+    app.post("/api/translation/session/stop", async () => {
         const project = await requireCurrentProject(deps.projectService);
         return deps.sessionService.stopProjectTranslatorSession(project.repoRoot);
     });
-    app.get("/api/translation/codex/source-files", async (request) => {
+    app.get("/api/translation/source-files", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
-        return deps.codexTranslationService.browseSourceFiles(project.repoRoot, {
+        return deps.translationWorkerService.browseSourceFiles(project.repoRoot, {
             path: request.query.path,
             query: request.query.query,
             limit: request.query.limit === undefined ? undefined : Number(request.query.limit)
         });
     });
-    app.post("/api/translation/codex/files", async (request) => {
+    app.post("/api/translation/files", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
-        return deps.codexTranslationService.createFileJob(project.repoRoot, request.body);
+        return deps.translationWorkerService.createFileJob(project.repoRoot, request.body);
     });
-    app.post("/api/translation/codex/bootstrap", async (request) => {
+    app.post("/api/translation/bootstrap", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
-        return deps.codexTranslationService.createBootstrapRun(project.repoRoot, request.body);
+        return deps.translationWorkerService.createBootstrapRun(project.repoRoot, request.body);
     });
-    app.post("/api/translation/codex/memory-update", async (request) => {
+    app.post("/api/translation/memory-update", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
-        return deps.codexTranslationService.createMemoryUpdate(project.repoRoot, request.body);
+        return deps.translationWorkerService.createMemoryUpdate(project.repoRoot, request.body);
     });
-    app.get("/api/translation/codex/files/:jobId", async (request) => {
+    app.get("/api/translation/files/:jobId", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
-        return deps.codexTranslationService.readFileJobOutput(project.repoRoot, request.params.jobId);
+        return deps.translationWorkerService.readFileJobOutput(project.repoRoot, request.params.jobId);
     });
-    app.post("/api/translation/codex/files/:jobId/promote", async (request) => {
+    app.post("/api/translation/files/:jobId/promote", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const targetPath = request.body?.targetPath?.trim();
         if (!targetPath) {
@@ -64,7 +64,7 @@ export function registerCodexTranslationRoutes(app, deps) {
                 statusCode: 400
             });
         }
-        return deps.codexTranslationService.promoteFileJob(project.repoRoot, request.params.jobId, targetPath);
+        return deps.translationWorkerService.promoteFileJob(project.repoRoot, request.params.jobId, targetPath);
     });
 }
 async function requireCurrentProject(projectService) {

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 { renderCodexCliConfigHarnessRules, renderCodexHooksHarnessRules, renderCodexTranslatorAgentsHarnessRules, renderCodexTranslatorConfigHarnessRules, renderGateReviewerAgentRules, renderRequestGateReviewTool, renderVcmGateReviewSkillRules } from "../templates/harness/gate-review.js";
+import { renderGateReviewerAgentRules, renderRequestGateReviewTool, renderTranslatorAgentRules, 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";
@@ -22,6 +22,12 @@ const APP_ROOT = path.resolve(CLI_DIR, "../../..");
 const MANIFEST_PATH = ".ai/vcm-harness-manifest.json";
 const HTML_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=\d+)? -->[\s\S]*?<!-- VCM:END -->/m;
 const HASH_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=\d+)?\n[\s\S]*?# VCM:END/m;
+const LEGACY_CODEX_HARNESS_PATHS = [
+    ".ai/codex",
+    ".ai/codex-translator",
+    ".claude/skills/vcm-codex-review-gate",
+    ".ai/tools/request-codex-review"
+];
 const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
 const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_PERMISSION_REQUEST_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
@@ -50,6 +56,9 @@ const AGENT_FRONTMATTER = {
     },
     "gate-reviewer": {
         description: "VCM independent gate review role for architecture plans, validation adequacy, and final diffs."
+    },
+    translator: {
+        description: "VCM project translation tool role for conversation translation, file translation, bootstrap, and memory updates."
     }
 };
 const MANAGED_FILES = [
@@ -117,11 +126,12 @@ const MANAGED_FILES = [
         content: renderGateReviewerAgentRules()
     },
     {
-        path: ".ai/codex-translator/AGENTS.md",
-        title: "VCM Codex Translator",
+        path: ".claude/agents/translator.md",
+        title: "Translator Agent",
+        agentName: "translator",
         commentStyle: "html",
-        category: "codex-translator-agent",
-        content: renderCodexTranslatorAgentsHarnessRules()
+        category: "agent-translator",
+        content: renderTranslatorAgentRules()
     }
 ];
 const DURABLE_DOC_TEMPLATES = [
@@ -181,24 +191,6 @@ const WHOLE_FILES = [
         mode: 0o644,
         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",
-        category: "codex-translator-config",
-        mode: 0o644,
-        content: renderCodexTranslatorConfigHarnessRules()
-    },
-    {
-        path: ".ai/codex-translator/.codex/config.toml",
-        category: "codex-translator-hooks",
-        mode: 0o644,
-        content: renderCodexCliConfigHarnessRules()
-    },
-    {
-        path: ".ai/codex-translator/.codex/hooks.json",
-        category: "codex-translator-hooks",
-        mode: 0o644,
-        content: renderCodexHooksHarnessRules("codex-translator")
-    },
     {
         path: ".ai/tools/request-gate-review",
         category: "runtime-tool",
@@ -271,6 +263,7 @@ async function main() {
         await installWholeFile({ projectRoot, file, dryRun, operations });
     }
     await removeLegacyFlatSkillFiles({ projectRoot, dryRun, operations });
+    await removeLegacyCodexHarnessPaths({ projectRoot, dryRun, operations });
     printReport({ projectRoot, dryRun, operations });
 }
 function parseArgs(argv) {
@@ -417,8 +410,6 @@ function fixedDirectories() {
         ".claude/skills/vcm-long-running-validation/",
         ".claude/skills/vcm-route-message/",
         ".claude/skills/vcm-gate-review/",
-        ".ai/codex-translator/",
-        ".ai/codex-translator/.codex/",
         ".ai/vcm/translations/",
         ".ai/vcm/gate-reviews/",
         ".ai/tools/",
@@ -632,6 +623,20 @@ async function removeLegacyFlatSkillFiles({ projectRoot, dryRun, operations }) {
         operations.push(done(legacy.path, "deleted legacy flat skill file"));
     }
 }
+async function removeLegacyCodexHarnessPaths({ projectRoot, dryRun, operations }) {
+    for (const relativePath of LEGACY_CODEX_HARNESS_PATHS) {
+        const targetPath = resolveInside(projectRoot, relativePath);
+        if (!await pathExists(targetPath)) {
+            continue;
+        }
+        if (dryRun) {
+            operations.push(plan(relativePath, "delete legacy Codex harness path"));
+            continue;
+        }
+        await fs.rm(targetPath, { recursive: true, force: true });
+        operations.push(done(relativePath, "deleted legacy Codex harness path"));
+    }
+}
 function stripSkillFrontmatter(content) {
     return content.replace(/^---\n[\s\S]*?\n---\n\n/, "");
 }

package/dist/backend/gateway/gateway-service.js

@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import { VCM_ROLE_DEFINITIONS } from "../../shared/constants.js";
+import { CORE_VCM_ROLE_DEFINITIONS, CORE_VCM_ROLE_NAMES, GATE_REVIEWER_ROLE_DEFINITION } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
@@ -407,17 +407,36 @@ export function createGatewayService(deps) {
             taskSlug: task.taskSlug,
             mode: template.autoOrchestration ? "auto" : "manual"
         });
+        const gateReviewSettings = await deps.appSettings.getGateReviewSettings(project.repoRoot, task.taskSlug);
+        const roleDefinitions = [
+            ...CORE_VCM_ROLE_DEFINITIONS,
+            ...(gateReviewSettings.enabled ? [GATE_REVIEWER_ROLE_DEFINITION] : [])
+        ];
         const startedRoles = [];
-        for (const definition of VCM_ROLE_DEFINITIONS) {
+        for (const definition of roleDefinitions) {
             const roleTemplate = template.roles[definition.name];
             try {
-                await deps.sessionService.startRoleSession(project.repoRoot, task.taskSlug, definition.name, {
+                const sessionInput = {
                     cols: 100,
                     rows: 28,
                     permissionMode: roleTemplate.permissionMode,
                     model: roleTemplate.model,
                     effort: roleTemplate.effort
-                });
+                };
+                const existing = await deps.sessionService.getRoleSession(project.repoRoot, task.taskSlug, definition.name);
+                if (existing?.status === "running") {
+                    if (definition.name === "gate-reviewer") {
+                        await deps.sessionService.resumeRoleSession(project.repoRoot, task.taskSlug, definition.name, sessionInput);
+                    }
+                    startedRoles.push(definition.name);
+                    continue;
+                }
+                if (existing?.claudeSessionId) {
+                    await deps.sessionService.resumeRoleSession(project.repoRoot, task.taskSlug, definition.name, sessionInput);
+                }
+                else {
+                    await deps.sessionService.startRoleSession(project.repoRoot, task.taskSlug, definition.name, sessionInput);
+                }
                 startedRoles.push(definition.name);
             }
             catch (error) {
@@ -536,7 +555,7 @@ export function createGatewayService(deps) {
     async function stopRunningRoleSessions(repoRoot, taskSlug) {
         const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
         for (const session of sessions) {
-            if (session.status === "running") {
+            if (session.status === "running" && CORE_VCM_ROLE_NAMES.some((role) => role === session.role)) {
                 await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
             }
         }

package/dist/backend/server.js

@@ -7,12 +7,11 @@ import { createClaudeAdapter } from "./adapters/claude-adapter.js";
 import { createCommandRunner } from "./adapters/command-runner.js";
 import { createCommandDispatcher } from "./services/command-dispatcher.js";
 import { createClaudeHookService } from "./services/claude-hook-service.js";
-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 { createGateReviewService } from "./services/gate-review-service.js";
-import { createCodexTranslationService } from "./services/codex-translation-service.js";
+import { createTranslationWorkerService } from "./services/translation-worker-service.js";
 import { createHarnessService, createScriptFixedHarnessInstaller } from "./services/harness-service.js";
 import { createNodeFileSystemAdapter } from "./adapters/filesystem.js";
 import { createNodePtyTerminalRuntime } from "./runtime/node-pty-runtime.js";
@@ -22,7 +21,6 @@ import { createWeixinIlinkChannel } from "./gateway/channels/weixin-ilink-channe
 import { createGatewayAuditLog } from "./gateway/gateway-audit-log.js";
 import { createGatewayService } from "./gateway/gateway-service.js";
 import { createGatewaySettingsService } from "./gateway/gateway-settings-service.js";
-import { resolveCodexSandboxMode } from "./codex-sandbox-mode.js";
 import { createJobGuardService } from "./services/job-guard-service.js";
 import { createProjectService } from "./services/project-service.js";
 import { createSessionRegistry } from "./runtime/session-registry.js";
@@ -36,9 +34,8 @@ import { createDiagnosticsService } from "./services/diagnostics-service.js";
 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 { registerGateReviewRoutes } from "./api/gate-review-routes.js";
-import { registerCodexTranslationRoutes } from "./api/codex-translation-routes.js";
+import { registerTranslationWorkerRoutes } from "./api/translation-worker-routes.js";
 import { registerHarnessRoutes } from "./api/harness-routes.js";
 import { registerMessageRoutes } from "./api/message-routes.js";
 import { registerProjectRoutes } from "./api/project-routes.js";
@@ -66,19 +63,18 @@ export async function createServer(deps, options = {}) {
     registerDiagnosticsRoutes(app, { diagnosticsService: deps.diagnosticsService });
     registerAppSettingsRoutes(app, { appSettings: deps.appSettings });
     registerClaudeHookRoutes(app, { claudeHookService: deps.claudeHookService });
-    registerCodexHookRoutes(app, { codexHookService: deps.codexHookService });
     registerGateReviewRoutes(app, {
         projectService: deps.projectService,
         gateReviewService: deps.gateReviewService
     });
-    registerCodexTranslationRoutes(app, {
+    registerTranslationWorkerRoutes(app, {
         projectService: deps.projectService,
-        codexTranslationService: deps.codexTranslationService,
+        translationWorkerService: deps.translationWorkerService,
         sessionService: deps.sessionService
     });
     registerProjectRoutes(app, {
         projectService: deps.projectService,
-        codexTranslationService: deps.codexTranslationService
+        translationWorkerService: deps.translationWorkerService
     });
     registerHarnessRoutes(app, {
         projectService: deps.projectService,
@@ -142,7 +138,7 @@ export async function createServer(deps, options = {}) {
 }
 async function cleanupRecentTranslationRuntime(deps) {
     const repoRoots = await deps.projectService.getRecentRepositoryPaths();
-    await Promise.all(repoRoots.map((repoRoot) => deps.codexTranslationService.cleanupStartupRuntime(repoRoot)));
+    await Promise.all(repoRoots.map((repoRoot) => deps.translationWorkerService.cleanupStartupRuntime(repoRoot)));
 }
 export async function startServer(options = {}) {
     const host = options.host ?? "127.0.0.1";
@@ -186,8 +182,7 @@ export function createDefaultServerDeps(options = {}) {
         artifactService,
         projectService,
         taskService,
-        apiUrl: options.apiUrl,
-        sandboxMode: resolveCodexSandboxMode(process.env)
+        apiUrl: options.apiUrl
     });
     const commandDispatcher = createCommandDispatcher({
         runtime,
@@ -223,7 +218,7 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         roundService
     });
-    const codexTranslationService = createCodexTranslationService({
+    const translationWorkerService = createTranslationWorkerService({
         fs,
         runtime,
         sessionService
@@ -234,7 +229,7 @@ export function createDefaultServerDeps(options = {}) {
         sessionRegistry: registry,
         transcripts,
         sessionService,
-        codexTranslationService,
+        translationWorkerService,
         fs,
         projectService,
         appSettings
@@ -268,12 +263,8 @@ export function createDefaultServerDeps(options = {}) {
         appSettings,
         runtime,
         gatewayService,
-        jobGuard: createJobGuardService()
-    });
-    const codexHookService = createCodexHookService({
-        projectService,
-        sessionService,
-        codexTranslationService
+        jobGuard: createJobGuardService(),
+        translationWorkerService
     });
     const diagnosticsService = createDiagnosticsService({
         appRoot: getAppRoot(),
@@ -290,10 +281,9 @@ export function createDefaultServerDeps(options = {}) {
         harnessService,
         commandDispatcher,
         claudeHookService,
-        codexHookService,
         messageService,
         gateReviewService,
-        codexTranslationService,
+        translationWorkerService,
         roundService,
         statusService,
         translationService,