vibe-coding-master 0.3.29 → 0.3.30

package/README.md

@@ -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.
@@ -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
@@ -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/{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/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,

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

@@ -1,4 +1,4 @@
-import { isGateReviewerRoleName, isVcmRoleName } from "../../shared/constants.js";
+import { isGateReviewerRoleName, isTranslatorToolRoleName, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
@@ -33,6 +33,36 @@ export function createClaudeHookService(deps) {
             taskRepoRoot
         };
     }
+    async function getTranslatorHookContext() {
+        const project = await deps.projectService.getCurrentProject();
+        if (!project) {
+            throw new VcmError({
+                code: "PROJECT_NOT_CONNECTED",
+                message: "Connect a repository before accepting Translator hooks.",
+                statusCode: 409
+            });
+        }
+        return { project };
+    }
+    async function processTranslatorHook(input) {
+        const eventName = parseHookEvent(input.event.hook_event_name);
+        const context = await getTranslatorHookContext();
+        const session = await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
+            eventName,
+            sessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd)
+        });
+        await deps.translationWorkerService?.handleTranslatorHook(context.project.repoRoot, eventName, input.taskSlug);
+        return {
+            ok: true,
+            eventName,
+            taskSlug: input.taskSlug,
+            role: input.role,
+            sessionUpdated: Boolean(session),
+            dispatchedCount: 0
+        };
+    }
     async function resolveHookTaskSlug(repoRoot, input) {
         if (!isGateReviewerRoleName(input.role)) {
             return input.taskSlug;
@@ -307,6 +337,20 @@ export function createClaudeHookService(deps) {
     }
     async function handlePermissionRequestHook(input) {
         if (!isVcmRoleName(input.role)) {
+            if (isTranslatorToolRoleName(input.role)) {
+                const preferences = await deps.appSettings.getPreferences();
+                if (preferences.permissionRequestMode !== "allowAll") {
+                    return undefined;
+                }
+                return {
+                    hookSpecificOutput: {
+                        hookEventName: "PermissionRequest",
+                        decision: {
+                            behavior: "allow"
+                        }
+                    }
+                };
+            }
             throw new VcmError({
                 code: "HOOK_ROLE_INVALID",
                 message: `Unknown hook role: ${input.role}`,
@@ -337,6 +381,9 @@ export function createClaudeHookService(deps) {
     }
     return {
         async handleHook(input) {
+            if (isTranslatorToolRoleName(input.role)) {
+                return processTranslatorHook(input);
+            }
             const eventName = parseHookEvent(input.event.hook_event_name);
             if (eventName === "UserPromptSubmit") {
                 return handleUserPromptSubmitHook(input);
@@ -352,6 +399,9 @@ export function createClaudeHookService(deps) {
             return processStopHook(input, { allowBlock: false });
         },
         handleStopHook(input) {
+            if (isTranslatorToolRoleName(input.role)) {
+                return processTranslatorHook(input);
+            }
             return processStopHook(input, { allowBlock: true });
         },
         handlePermissionRequestHook

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

@@ -4,7 +4,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { renderArchitectHarnessRules } from "../templates/harness/architect-agent.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
-import { 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";
@@ -25,6 +25,12 @@ export const VCM_HARNESS_VERSION = 1;
 const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!-- VCM:END -->/m;
 const HASH_MANAGED_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=(\d+))?\n[\s\S]*?# VCM:END/m;
 const CLAUDE_SETTINGS_PATH = ".claude/settings.json";
+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'`;
@@ -107,31 +113,11 @@ const HARNESS_FILES = [
         renderRules: renderGateReviewerAgentRules
     },
     {
-        kind: "codex-translator-agents",
-        path: ".ai/codex-translator/AGENTS.md",
-        title: "VCM Codex Translator",
-        renderRules: renderCodexTranslatorAgentsHarnessRules
-    },
-    {
-        kind: "codex-translator-config",
-        path: ".ai/codex-translator/config.toml",
-        title: "VCM Codex Translator Config",
-        ownership: "raw-file",
-        renderRules: renderCodexTranslatorConfigHarnessRules
-    },
-    {
-        kind: "codex-translator-cli-config",
-        path: ".ai/codex-translator/.codex/config.toml",
-        title: "VCM Codex Translator CLI Config",
-        ownership: "raw-file",
-        renderRules: renderCodexCliConfigHarnessRules
-    },
-    {
-        kind: "codex-translator-hooks",
-        path: ".ai/codex-translator/.codex/hooks.json",
-        title: "VCM Codex Translator Hooks",
-        ownership: "raw-file",
-        renderRules: () => renderCodexHooksHarnessRules("codex-translator")
+        kind: "agent-translator",
+        path: ".claude/agents/translator.md",
+        title: "Translator Agent",
+        frontmatter: renderAgentFrontmatter("translator", "VCM project translation tool role for conversation translation, file translation, bootstrap, and memory updates."),
+        renderRules: renderTranslatorAgentRules
     },
     {
         kind: "tool-request-gate-review",
@@ -175,7 +161,8 @@ export function createHarnessService(deps) {
     return {
         async getHarnessStatus(repoRoot) {
             const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
-            return renderHarnessStatus(analyses);
+            const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
+            return renderHarnessStatus(analyses, legacyChanges);
         },
         async applyHarness(repoRoot) {
             if (deps.runFixedInstaller) {
@@ -192,6 +179,8 @@ export function createHarnessService(deps) {
                     changedFiles.push(analysis.plannedChange);
                 }
             }
+            const legacyChanges = await removeLegacyCodexHarnessPaths(deps.fs, repoRoot);
+            changedFiles.push(...legacyChanges);
             return {
                 version: VCM_HARNESS_VERSION,
                 changedFiles,
@@ -489,11 +478,42 @@ async function analyzeHarnessFile(fs, repoRoot, definition) {
             : currentContent.replace(managedBlockPattern, expectedBlock)
     };
 }
-function renderHarnessStatus(analyses) {
+async function analyzeLegacyCodexHarnessPaths(fs, repoRoot) {
+    const changes = [];
+    for (const relativePath of LEGACY_CODEX_HARNESS_PATHS) {
+        if (!await fs.pathExists(resolveHarnessPath(repoRoot, relativePath))) {
+            continue;
+        }
+        changes.push({
+            path: relativePath,
+            action: "delete",
+            reason: "Legacy Codex harness path is obsolete; VCM now uses Claude Code Gate Reviewer and Translator roles."
+        });
+    }
+    return changes;
+}
+async function removeLegacyCodexHarnessPaths(fs, repoRoot) {
+    const changes = await analyzeLegacyCodexHarnessPaths(fs, repoRoot);
+    if (changes.length === 0) {
+        return [];
+    }
+    if (!fs.removePath) {
+        return [];
+    }
+    for (const change of changes) {
+        await fs.removePath(resolveHarnessPath(repoRoot, change.path), {
+            recursive: true,
+            force: true
+        });
+    }
+    return changes;
+}
+function renderHarnessStatus(analyses, legacyChanges = []) {
     const files = analyses.map((analysis) => analysis.status);
     const plannedChanges = analyses
         .map((analysis) => analysis.plannedChange)
-        .filter((change) => Boolean(change));
+        .filter((change) => Boolean(change))
+        .concat(legacyChanges);
     // Derive `initialized`: the VCM harness is considered installed when at least one
     // VCM-exclusive marker is present (per analysis):
     //   - status.hasManagedBlock === true (a managed block already lives in the file), OR