vibe-coding-master 0.3.28 → 0.3.30

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

@@ -1,16 +1,14 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
-import { VCM_ROLE_NAMES, isCodexRoleName, isDispatchableRole } from "../../shared/constants.js";
+import { CORE_VCM_ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { claudeTranscriptPath } from "./claude-transcript-service.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const GATE_REVIEWER_ROLE = "gate-reviewer";
-const CODEX_TRANSLATOR_ROLE = "codex-translator";
-const CODEX_TRANSLATOR_DIR = ".ai/codex-translator";
-const CODEX_TRANSLATION_DIR = ".ai/vcm/translations";
-const CODEX_TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
-const CODEX_TRANSLATOR_CONFIG_PATH = ".ai/codex-translator/config.toml";
+const TRANSLATOR_ROLE = "translator";
+const TRANSLATION_DIR = ".ai/vcm/translations";
+const TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
 const GATE_REVIEWER_SESSION_PATH = ".ai/vcm/gate-reviewer/session.json";
 const PROJECT_TRANSLATOR_SCOPE = "__project__";
 const PROJECT_GATE_REVIEWER_SCOPE = "__project_gate_reviewer__";
@@ -26,16 +24,9 @@ export function createSessionService(deps) {
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         const persisted = await loadPersistedRoleRecordForRole(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, taskSlug, role);
-        const isCodexRole = isCodexRoleName(role);
-        const isTranslator = role === CODEX_TRANSLATOR_ROLE;
-        const sessionRepoRoot = isTranslator ? repoRoot : taskRepoRoot;
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
-        const model = isCodexRole
-            ? normalizeCodexModel(input.model ?? persisted?.model)
-            : normalizeClaudeModel(input.model ?? persisted?.model);
-        const effort = isCodexRole
-            ? normalizeCodexEffort(input.effort ?? persisted?.effort)
-            : normalizeClaudeEffort(input.effort ?? persisted?.effort);
+        const model = normalizeClaudeModel(input.model ?? persisted?.model);
+        const effort = normalizeClaudeEffort(input.effort ?? persisted?.effort);
         const claudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : randomUUID();
@@ -49,13 +40,11 @@ export function createSessionService(deps) {
         }
         const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
             ? persisted.transcriptPath
-            : isCodexRole ? undefined : claudeTranscriptPath(taskRepoRoot, claudeSessionId);
-        const startCommand = isCodexRole
-            ? await buildCodexStartCommand(deps.fs, repoRoot, taskRepoRoot, role, launchMode, model, effort, deps.sandboxMode, launchMode === "resume" && hasCapturedCodexSession(persisted) ? claudeSessionId : undefined)
-            : {
-                ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model, effort),
-                cwd: taskRepoRoot
-            };
+            : claudeTranscriptPath(taskRepoRoot, claudeSessionId);
+        const startCommand = {
+            ...deps.claude.buildRoleStartCommand(role, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model, effort),
+            cwd: taskRepoRoot
+        };
         const runtimeSession = await deps.runtime.createSession({
             taskSlug,
             role,
@@ -64,7 +53,7 @@ export function createSessionService(deps) {
             cwd: startCommand.cwd,
             env: {
                 VCM_API_URL: deps.apiUrl,
-                VCM_TASK_REPO_ROOT: sessionRepoRoot,
+                VCM_TASK_REPO_ROOT: taskRepoRoot,
                 VCM_TASK_SLUG: taskSlug,
                 VCM_ROLE: role,
                 VCM_SESSION_ID: claudeSessionId
@@ -101,10 +90,10 @@ export function createSessionService(deps) {
         await persistRoleSessionRecord(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, record);
         return record;
     }
-    async function launchProjectGateReviewerSession(repoRoot, input, launchMode) {
+    async function launchProjectGateReviewerSession(repoRoot, input, launchMode, activeTaskSlug) {
         const live = toRoleSessionRecordView(getRegisteredProjectGateReviewerSession(deps.registry, deps.runtime), deps.runtime);
         if (live && live.status === "running") {
-            return live;
+            return bindProjectGateReviewerSession(repoRoot, live, activeTaskSlug);
         }
         const config = await deps.projectService.loadConfig(repoRoot);
         const persisted = await loadPersistedProjectGateReviewerSession(deps.fs, repoRoot);
@@ -125,6 +114,10 @@ export function createSessionService(deps) {
         const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
             ? persisted.transcriptPath
             : claudeTranscriptPath(repoRoot, claudeSessionId);
+        const activeTask = activeTaskSlug
+            ? await deps.taskService.loadTask(repoRoot, activeTaskSlug)
+            : undefined;
+        const activeTaskRepoRoot = activeTask ? getTaskRuntimeRepoRoot(activeTask) : undefined;
         const startCommand = {
             ...deps.claude.buildRoleStartCommand(GATE_REVIEWER_ROLE, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model, effort),
             cwd: repoRoot
@@ -137,8 +130,8 @@ export function createSessionService(deps) {
             cwd: startCommand.cwd,
             env: {
                 VCM_API_URL: deps.apiUrl,
-                VCM_TASK_REPO_ROOT: repoRoot,
-                VCM_TASK_SLUG: PROJECT_GATE_REVIEWER_SCOPE,
+                VCM_TASK_REPO_ROOT: activeTaskRepoRoot ?? repoRoot,
+                VCM_TASK_SLUG: activeTaskSlug ?? PROJECT_GATE_REVIEWER_SCOPE,
                 VCM_ROLE: GATE_REVIEWER_ROLE,
                 VCM_SESSION_ID: claudeSessionId
             },
@@ -164,35 +157,63 @@ export function createSessionService(deps) {
             startedAt: runtimeSession.startedAt,
             updatedAt: timestamp,
             lastOutputAt: runtimeSession.lastOutputAt,
+            activeTaskSlug,
+            activeTaskRepoRoot,
             exitCode: runtimeSession.exitCode
         };
         deps.registry.upsert(record);
         await persistProjectGateReviewerSession(deps.fs, repoRoot, record);
         return record;
     }
+    async function bindProjectGateReviewerSession(repoRoot, record, activeTaskSlug) {
+        if (!activeTaskSlug) {
+            return record;
+        }
+        const task = await deps.taskService.loadTask(repoRoot, activeTaskSlug);
+        const activeTaskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const updated = {
+            ...record,
+            taskSlug: PROJECT_GATE_REVIEWER_SCOPE,
+            activeTaskSlug,
+            activeTaskRepoRoot,
+            updatedAt: now()
+        };
+        deps.registry.upsert(updated);
+        await persistProjectGateReviewerSession(deps.fs, repoRoot, updated);
+        return updated;
+    }
     async function launchProjectTranslatorSession(repoRoot, input, launchMode) {
         const live = toRoleSessionRecordView(getRegisteredProjectTranslatorSession(deps.registry, deps.runtime), deps.runtime);
         if (live && live.status === "running") {
             return live;
         }
-        const persisted = await loadPersistedCodexTranslatorSession(deps.fs, repoRoot);
-        const model = normalizeCodexModel(input.model ?? persisted?.model);
-        const effort = normalizeCodexEffort(input.effort ?? persisted?.effort);
+        const config = await deps.projectService.loadConfig(repoRoot);
+        const persisted = await loadPersistedTranslatorSession(deps.fs, repoRoot);
+        const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
+        const model = normalizeClaudeModel(input.model ?? persisted?.model);
+        const effort = normalizeClaudeEffort(input.effort ?? persisted?.effort);
         const claudeSessionId = launchMode === "resume"
             ? persisted?.claudeSessionId
             : randomUUID();
         if (!claudeSessionId) {
             throw new VcmError({
-                code: "CODEX_TRANSLATOR_SESSION_MISSING",
-                message: "Codex Translator does not have a session id to resume.",
+                code: "TRANSLATOR_SESSION_MISSING",
+                message: "Translator does not have a session id to resume.",
                 statusCode: 409,
                 hint: "Start the translator once before using Resume."
             });
         }
-        const startCommand = await buildCodexStartCommand(deps.fs, repoRoot, repoRoot, CODEX_TRANSLATOR_ROLE, launchMode, model, effort, deps.sandboxMode, launchMode === "resume" && hasCapturedCodexSession(persisted) ? claudeSessionId : undefined);
+        await deps.fs.ensureDir(resolveRepoPath(repoRoot, TRANSLATION_DIR));
+        const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
+            ? persisted.transcriptPath
+            : claudeTranscriptPath(repoRoot, claudeSessionId);
+        const startCommand = {
+            ...deps.claude.buildRoleStartCommand(TRANSLATOR_ROLE, config.claudeCommand, permissionMode, claudeSessionId, launchMode === "resume", model, effort),
+            cwd: repoRoot
+        };
         const runtimeSession = await deps.runtime.createSession({
             taskSlug: PROJECT_TRANSLATOR_SCOPE,
-            role: CODEX_TRANSLATOR_ROLE,
+            role: TRANSLATOR_ROLE,
             command: startCommand.command,
             args: startCommand.args,
             cwd: startCommand.cwd,
@@ -200,7 +221,7 @@ export function createSessionService(deps) {
                 VCM_API_URL: deps.apiUrl,
                 VCM_TASK_REPO_ROOT: repoRoot,
                 VCM_TASK_SLUG: PROJECT_TRANSLATOR_SCOPE,
-                VCM_ROLE: CODEX_TRANSLATOR_ROLE,
+                VCM_ROLE: TRANSLATOR_ROLE,
                 VCM_SESSION_ID: claudeSessionId
             },
             cols: input.cols,
@@ -210,12 +231,13 @@ export function createSessionService(deps) {
         const record = {
             id: runtimeSession.id,
             claudeSessionId,
+            transcriptPath,
             taskSlug: PROJECT_TRANSLATOR_SCOPE,
-            role: CODEX_TRANSLATOR_ROLE,
+            role: TRANSLATOR_ROLE,
             status: runtimeSession.status,
             activityStatus: "idle",
             command: startCommand.display,
-            permissionMode: "default",
+            permissionMode,
             model,
             effort,
             cwd: startCommand.cwd,
@@ -227,7 +249,7 @@ export function createSessionService(deps) {
             exitCode: runtimeSession.exitCode
         };
         deps.registry.upsert(record);
-        await persistCodexTranslatorSession(deps.fs, repoRoot, record);
+        await persistTranslatorSession(deps.fs, repoRoot, record);
         return record;
     }
     return {
@@ -303,7 +325,7 @@ export function createSessionService(deps) {
             if (!existing) {
                 throw new VcmError({
                     code: "SESSION_MISSING",
-                    message: "Codex Translator session has not been started.",
+                    message: "Translator session has not been started.",
                     statusCode: 404
                 });
             }
@@ -317,7 +339,7 @@ export function createSessionService(deps) {
                 updatedAt: now()
             };
             deps.registry.upsert(updated);
-            await persistCodexTranslatorSession(deps.fs, repoRoot, updated);
+            await persistTranslatorSession(deps.fs, repoRoot, updated);
             return updated;
         },
         async restartProjectTranslatorSession(repoRoot, input = {}) {
@@ -333,7 +355,7 @@ export function createSessionService(deps) {
         },
         async getProjectTranslatorSession(repoRoot) {
             const record = getRegisteredProjectTranslatorSession(deps.registry, deps.runtime)
-                ?? await loadPersistedCodexTranslatorSession(deps.fs, repoRoot);
+                ?? await loadPersistedTranslatorSession(deps.fs, repoRoot);
             return toRoleSessionRecordView(record, deps.runtime);
         },
         async ensureProjectTranslatorSession(repoRoot, input = {}) {
@@ -372,15 +394,15 @@ export function createSessionService(deps) {
                 updatedAt: timestamp
             };
             deps.registry.upsert(updated);
-            await persistCodexTranslatorSession(deps.fs, repoRoot, updated);
+            await persistTranslatorSession(deps.fs, repoRoot, updated);
             return updated;
         },
         startRoleSession(repoRoot, taskSlug, role, input = {}) {
             if (role === GATE_REVIEWER_ROLE) {
-                return this.startProjectGateReviewerSession(repoRoot, input)
+                return launchProjectGateReviewerSession(repoRoot, input, "fresh", taskSlug)
                     .then((session) => scopeProjectRoleSession(session, taskSlug));
             }
-            if (role === CODEX_TRANSLATOR_ROLE) {
+            if (role === TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.startProjectTranslatorSession(repoRoot, input);
             }
@@ -388,10 +410,10 @@ export function createSessionService(deps) {
         },
         resumeRoleSession(repoRoot, taskSlug, role, input = {}) {
             if (role === GATE_REVIEWER_ROLE) {
-                return this.resumeProjectGateReviewerSession(repoRoot, input)
+                return launchProjectGateReviewerSession(repoRoot, input, "resume", taskSlug)
                     .then((session) => scopeProjectRoleSession(session, taskSlug));
             }
-            if (role === CODEX_TRANSLATOR_ROLE) {
+            if (role === TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.resumeProjectTranslatorSession(repoRoot, input);
             }
@@ -401,7 +423,7 @@ export function createSessionService(deps) {
             if (role === GATE_REVIEWER_ROLE) {
                 return scopeProjectRoleSession(await this.stopProjectGateReviewerSession(repoRoot), taskSlug);
             }
-            if (role === CODEX_TRANSLATOR_ROLE) {
+            if (role === TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.stopProjectTranslatorSession(repoRoot);
             }
@@ -430,9 +452,16 @@ export function createSessionService(deps) {
         },
         async restartRoleSession(repoRoot, taskSlug, role, input = {}) {
             if (role === GATE_REVIEWER_ROLE) {
-                return scopeProjectRoleSession(await this.restartProjectGateReviewerSession(repoRoot, input), taskSlug);
+                const existing = await this.getProjectGateReviewerSession(repoRoot);
+                if (existing && deps.runtime.getSession(existing.id)) {
+                    await deps.runtime.stop(existing.id);
+                }
+                if (existing) {
+                    deps.registry.remove(existing.id);
+                }
+                return scopeProjectRoleSession(await launchProjectGateReviewerSession(repoRoot, input, "fresh", taskSlug), taskSlug);
             }
-            if (role === CODEX_TRANSLATOR_ROLE) {
+            if (role === TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.restartProjectTranslatorSession(repoRoot, input);
             }
@@ -448,9 +477,13 @@ export function createSessionService(deps) {
         },
         async getRoleSession(repoRoot, taskSlug, role) {
             if (role === GATE_REVIEWER_ROLE) {
-                return scopeProjectRoleSession(await this.getProjectGateReviewerSession(repoRoot), taskSlug);
+                const session = await this.getProjectGateReviewerSession(repoRoot);
+                if (!session) {
+                    return undefined;
+                }
+                return scopeProjectRoleSession(await bindProjectGateReviewerSession(repoRoot, session, taskSlug), taskSlug);
             }
-            if (role === CODEX_TRANSLATOR_ROLE) {
+            if (role === TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.getProjectTranslatorSession(repoRoot);
             }
@@ -470,7 +503,7 @@ export function createSessionService(deps) {
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const persistedTaskSession = await loadPersistedTaskSessionRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug);
-            for (const role of VCM_ROLE_NAMES) {
+            for (const role of CORE_VCM_ROLE_NAMES) {
                 const record = deps.registry.getByRole(taskSlug, role)
                     ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record);
                 const session = toRoleSessionRecordView(record, deps.runtime);
@@ -510,7 +543,7 @@ export function createSessionService(deps) {
                 await persistProjectGateReviewerSession(deps.fs, repoRoot, updated);
                 return scopeProjectRoleSession(updated, input.taskSlug);
             }
-            if (input.role === CODEX_TRANSLATOR_ROLE) {
+            if (input.role === TRANSLATOR_ROLE) {
                 void input.taskSlug;
                 return this.recordProjectTranslatorHookEvent(repoRoot, {
                     eventName: input.eventName,
@@ -633,80 +666,6 @@ function toRoleSessionRecordView(record, runtime) {
         exitCode: runtimeSession.exitCode
     };
 }
-async function buildCodexStartCommand(fs, baseRepoRoot, _taskRepoRoot, role, launchMode, selectedModel, selectedEffort, sandboxMode, resumeSessionId) {
-    const isTranslator = role === CODEX_TRANSLATOR_ROLE;
-    if (!isTranslator) {
-        throw new VcmError({
-            code: "CODEX_ROLE_UNSUPPORTED",
-            message: `${role} is not a Codex role.`,
-            statusCode: 400
-        });
-    }
-    const codexDir = resolveRepoPath(baseRepoRoot, CODEX_TRANSLATOR_DIR);
-    const outputDir = resolveRepoPath(baseRepoRoot, CODEX_TRANSLATION_DIR);
-    if (!(await fs.pathExists(codexDir))) {
-        throw new VcmError({
-            code: "CODEX_TRANSLATOR_CONFIG_MISSING",
-            message: `${CODEX_TRANSLATOR_DIR} does not exist.`,
-            statusCode: 409,
-            hint: "Apply the VCM harness before starting Codex Translator."
-        });
-    }
-    await fs.ensureDir(outputDir);
-    const config = await loadCodexSessionConfig(fs, baseRepoRoot, CODEX_TRANSLATOR_CONFIG_PATH);
-    const args = launchMode === "resume"
-        ? resumeSessionId ? ["resume", resumeSessionId] : ["resume", "--last"]
-        : [];
-    args.push("--cd", codexDir);
-    if (isDevContainerSandbox(sandboxMode)) {
-        args.push("--dangerously-bypass-approvals-and-sandbox");
-    }
-    else {
-        args.push("--add-dir", baseRepoRoot);
-        args.push("--sandbox", "workspace-write", "--ask-for-approval", "never");
-    }
-    args.push("--dangerously-bypass-hook-trust", "--search");
-    if (selectedModel !== "default") {
-        args.push("--model", selectedModel);
-    }
-    if (selectedEffort !== "default") {
-        args.push("--config", `model_reasoning_effort="${selectedEffort}"`);
-    }
-    return {
-        command: config.command,
-        args,
-        cwd: baseRepoRoot,
-        display: [config.command, ...args].map(formatDisplayArg).join(" ")
-    };
-}
-function hasCapturedCodexSession(record) {
-    return Boolean(record?.lastHookEventAt || record?.transcriptPath);
-}
-function isDevContainerSandbox(value) {
-    const normalized = value?.toLowerCase().replace(/[\s_-]+/g, "");
-    return normalized === "devcontainer" ||
-        normalized === "container" ||
-        normalized === "docker" ||
-        normalized === "podman" ||
-        normalized === "codespaces" ||
-        normalized === "bypass" ||
-        normalized === "nosandbox" ||
-        normalized === "disabled" ||
-        normalized === "off" ||
-        normalized === "none";
-}
-async function loadCodexSessionConfig(fs, repoRoot, configRelativePath) {
-    const configPath = resolveRepoPath(repoRoot, configRelativePath);
-    if (!(await fs.pathExists(configPath))) {
-        return {
-            command: "codex"
-        };
-    }
-    const content = await fs.readText(configPath);
-    return {
-        command: parseTomlString(content, "command") ?? "codex"
-    };
-}
 function matchesRoleHookSession(record, input) {
     if (input.sessionId && record.claudeSessionId === input.sessionId) {
         return true;
@@ -744,7 +703,7 @@ function getHandoffArtifactPath(paths, role) {
     return undefined;
 }
 function getRegisteredRoleSession(registry, runtime, taskSlug, role) {
-    if (role !== CODEX_TRANSLATOR_ROLE && role !== GATE_REVIEWER_ROLE) {
+    if (role !== TRANSLATOR_ROLE && role !== GATE_REVIEWER_ROLE) {
         return registry.getByRole(taskSlug, role);
     }
     const candidates = registry.list().filter((session) => session.role === role);
@@ -760,7 +719,7 @@ function getRegisteredProjectGateReviewerSession(registry, runtime) {
     return live ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
 }
 function getRegisteredProjectTranslatorSession(registry, runtime) {
-    const candidates = registry.list().filter((session) => session.role === CODEX_TRANSLATOR_ROLE);
+    const candidates = registry.list().filter((session) => session.role === TRANSLATOR_ROLE);
     const live = candidates.find((session) => runtime.getSession(session.id)?.status === "running");
     return live ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
 }
@@ -768,7 +727,7 @@ function compareSessionUpdatedAtDesc(left, right) {
     return (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "");
 }
 function scopeProjectRoleSession(record, taskSlug) {
-    if (!record || (record.role !== CODEX_TRANSLATOR_ROLE && record.role !== GATE_REVIEWER_ROLE)) {
+    if (!record || (record.role !== TRANSLATOR_ROLE && record.role !== GATE_REVIEWER_ROLE)) {
         return record;
     }
     return {
@@ -781,9 +740,9 @@ async function loadPersistedRoleRecordForRole(fs, baseRepoRoot, taskRepoRoot, st
         void taskSlug;
         return loadPersistedProjectGateReviewerSession(fs, baseRepoRoot);
     }
-    if (role === CODEX_TRANSLATOR_ROLE) {
+    if (role === TRANSLATOR_ROLE) {
         void taskSlug;
-        return loadPersistedCodexTranslatorSession(fs, baseRepoRoot);
+        return loadPersistedTranslatorSession(fs, baseRepoRoot);
     }
     return loadPersistedRoleRecord(fs, taskRepoRoot, stateRoot, taskSlug, role);
 }
@@ -802,8 +761,8 @@ async function loadPersistedProjectGateReviewerSession(fs, repoRoot) {
         taskSlug: PROJECT_GATE_REVIEWER_SCOPE
     };
 }
-async function loadPersistedCodexTranslatorSession(fs, repoRoot) {
-    const sessionPath = resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH);
+async function loadPersistedTranslatorSession(fs, repoRoot) {
+    const sessionPath = resolveRepoPath(repoRoot, TRANSLATOR_SESSION_PATH);
     if (!(await fs.pathExists(sessionPath))) {
         return undefined;
     }
@@ -840,12 +799,8 @@ function normalizePersistedRoleRecord(record) {
                 ? legacy.lastStopAt
                 : undefined),
             permissionMode: normalizeClaudePermissionMode(record.permissionMode),
-            model: isCodexRoleName(record.role)
-                ? normalizeCodexModel(record.model)
-                : normalizeClaudeModel(record.model),
-            effort: isCodexRoleName(record.role)
-                ? normalizeCodexEffort(record.effort)
-                : normalizeClaudeEffort(record.effort)
+            model: normalizeClaudeModel(record.model),
+            effort: normalizeClaudeEffort(record.effort)
         }
         : undefined;
 }
@@ -879,8 +834,8 @@ async function persistRoleSessionRecord(fs, baseRepoRoot, taskRepoRoot, stateRoo
         await persistProjectGateReviewerSession(fs, baseRepoRoot, session);
         return;
     }
-    if (session.role === CODEX_TRANSLATOR_ROLE) {
-        await persistCodexTranslatorSession(fs, baseRepoRoot, session);
+    if (session.role === TRANSLATOR_ROLE) {
+        await persistTranslatorSession(fs, baseRepoRoot, session);
         return;
     }
     await persistTaskSession(fs, taskRepoRoot, stateRoot, session);
@@ -896,8 +851,8 @@ async function persistProjectGateReviewerSession(fs, repoRoot, session) {
         }
     });
 }
-async function persistCodexTranslatorSession(fs, repoRoot, session) {
-    await fs.writeJsonAtomic(resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH), {
+async function persistTranslatorSession(fs, repoRoot, session) {
+    await fs.writeJsonAtomic(resolveRepoPath(repoRoot, TRANSLATOR_SESSION_PATH), {
         version: 1,
         role: session.role,
         updatedAt: session.updatedAt,
@@ -943,12 +898,6 @@ function normalizeClaudeModel(value) {
     }
     return "default";
 }
-function normalizeCodexModel(value) {
-    if (value === "default" || value === "gpt-5.5") {
-        return value;
-    }
-    return "gpt-5.5";
-}
 function normalizeClaudeEffort(value) {
     if (value === "low"
         || value === "medium"
@@ -960,25 +909,3 @@ function normalizeClaudeEffort(value) {
     }
     return "default";
 }
-function normalizeCodexEffort(value) {
-    if (value === "low"
-        || value === "medium"
-        || value === "high"
-        || value === "xhigh") {
-        return value;
-    }
-    return "default";
-}
-function parseTomlString(content, key) {
-    const pattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"\\s*$`, "m");
-    return pattern.exec(content)?.[1];
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function formatDisplayArg(value) {
-    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) {
-        return value;
-    }
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}

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

@@ -7,8 +7,8 @@ const TRANSLATION_SOURCE_LANGUAGE = "auto";
 const TRANSLATION_INPUT_MODE = "review-before-send";
 const TRANSLATION_CONTEXT_ENABLED = false;
 const TRANSLATION_TIMEOUT_MS = 120000;
-const TRANSLATION_PROVIDER = "codex";
-const TRANSLATION_MODEL = "codex-translator";
+const TRANSLATION_PROVIDER = "claude-code";
+const TRANSLATION_MODEL = "translator";
 const OUTPUT_TRANSLATION_BATCH_DELAY_MS = 10000;
 const TRANSCRIPT_REPLAY_GRACE_MS = 5000;
 export function createTranslationService(deps) {
@@ -313,7 +313,7 @@ export function createTranslationService(deps) {
                 const jobs = [];
                 for (let index = 0; index < items.length; index += 1) {
                     const item = items[index];
-                    const job = await createCodexConversationJob({
+                    const job = await createConversationJob({
                         repoRoot: item.repoRoot,
                         taskSlug: item.entry.taskSlug,
                         role: item.entry.role,
@@ -329,7 +329,7 @@ export function createTranslationService(deps) {
                 }
                 for (const { item, job } of jobs) {
                     try {
-                        const result = await waitForCodexConversationResult(item.repoRoot, job, item.config.requestTimeoutMs);
+                        const result = await waitForConversationResult(item.repoRoot, job, item.config.requestTimeoutMs);
                         const completed = {
                             ...item.entry,
                             status: "translated",
@@ -882,28 +882,28 @@ export function createTranslationService(deps) {
         await submitTerminalInput(deps.runtime, record.id, text);
     }
     async function translateText(input) {
-        const job = await createCodexConversationJob(input);
-        const result = await waitForCodexConversationResult(input.repoRoot, job, input.config.requestTimeoutMs);
+        const job = await createConversationJob(input);
+        const result = await waitForConversationResult(input.repoRoot, job, input.config.requestTimeoutMs);
         return {
             text: result.translatedText
         };
     }
-    async function createCodexConversationJob(input) {
-        if (!deps.codexTranslationService) {
+    async function createConversationJob(input) {
+        if (!deps.translationWorkerService) {
             throw new VcmError({
-                code: "CODEX_TRANSLATION_UNAVAILABLE",
-                message: "Codex translation service is unavailable.",
+                code: "TRANSLATION_WORKER_UNAVAILABLE",
+                message: "translation service is unavailable.",
                 statusCode: 500
             });
         }
         if (!input.repoRoot) {
             throw new VcmError({
                 code: "TRANSLATION_REPO_ROOT_MISSING",
-                message: "Codex translation requires a base repository root.",
+                message: "translation requires a base repository root.",
                 statusCode: 500
             });
         }
-        return deps.codexTranslationService.createConversationJob(input.repoRoot, {
+        return deps.translationWorkerService.createConversationJob(input.repoRoot, {
             direction: input.direction,
             sourceText: input.text,
             sourceLanguage: input.sourceLanguage,
@@ -912,18 +912,18 @@ export function createTranslationService(deps) {
             deferDispatch: input.deferDispatch
         });
     }
-    async function waitForCodexConversationResult(repoRoot, job, timeoutMs) {
+    async function waitForConversationResult(repoRoot, job, timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         let lastError;
         while (Date.now() <= deadline) {
-            const state = await deps.codexTranslationService.getState(repoRoot);
+            const state = await deps.translationWorkerService.getState(repoRoot);
             const item = job.queueItemId
                 ? state.queue.items.find((candidate) => candidate.id === job.queueItemId)
                 : undefined;
             if (item && ["failed", "cancelled", "interrupted", "skipped"].includes(item.status)) {
                 throw new VcmError({
                     code: "TRANSLATION_FAILED",
-                    message: item.error ?? "Codex translation failed.",
+                    message: item.error ?? "translation failed.",
                     statusCode: 502
                 });
             }
@@ -932,7 +932,7 @@ export function createTranslationService(deps) {
                 continue;
             }
             try {
-                return await deps.codexTranslationService.validateConversationResult(repoRoot, {
+                return await deps.translationWorkerService.validateConversationResult(repoRoot, {
                     resultPath: job.resultPath,
                     sourceHash: job.sourceHash,
                     targetLanguage: job.targetLanguage
@@ -948,7 +948,7 @@ export function createTranslationService(deps) {
         }
         throw new VcmError({
             code: "TRANSLATION_TIMEOUT",
-            message: lastError instanceof Error ? `Codex translation timed out: ${lastError.message}` : "Codex translation timed out.",
+            message: lastError instanceof Error ? `translation timed out: ${lastError.message}` : "translation timed out.",
             statusCode: 504
         });
     }