vibe-coding-master 0.3.29 → 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 { CORE_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
@@ -198,24 +187,33 @@ export function createSessionService(deps) {
         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,
@@ -223,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,
@@ -233,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,
@@ -250,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 {
@@ -326,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
                 });
             }
@@ -340,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 = {}) {
@@ -356,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 = {}) {
@@ -395,7 +394,7 @@ 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 = {}) {
@@ -403,7 +402,7 @@ export function createSessionService(deps) {
                 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);
             }
@@ -414,7 +413,7 @@ export function createSessionService(deps) {
                 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);
             }
@@ -424,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);
             }
@@ -462,7 +461,7 @@ export function createSessionService(deps) {
                 }
                 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);
             }
@@ -484,7 +483,7 @@ export function createSessionService(deps) {
                 }
                 return scopeProjectRoleSession(await bindProjectGateReviewerSession(repoRoot, session, taskSlug), taskSlug);
             }
-            if (role === CODEX_TRANSLATOR_ROLE) {
+            if (role === TRANSLATOR_ROLE) {
                 void taskSlug;
                 return this.getProjectTranslatorSession(repoRoot);
             }
@@ -544,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,
@@ -667,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;
@@ -778,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);
@@ -794,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];
 }
@@ -802,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 {
@@ -815,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);
 }
@@ -836,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;
     }
@@ -874,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;
 }
@@ -913,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);
@@ -930,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,
@@ -977,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"
@@ -994,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
         });
     }

package/dist/backend/services/{codex-translation-service.js → translation-worker-service.js}

@@ -19,7 +19,7 @@ const DEFAULT_CHUNK_SOURCE_TOKEN_TARGET = 80000;
 const BOOTSTRAP_DEFAULT_LIMIT = 12;
 const MEMORY_TOTAL_LIMIT_BYTES = 80 * 1024;
 const MEMORY_FILE_NAMES = ["glossary.md", "style-guide.md", "project-context.md", "decisions.md"];
-const CODEX_TRANSLATOR_ROLE = "codex-translator";
+const TRANSLATOR_ROLE = "translator";
 const FILE_BROWSER_DEFAULT_LIMIT = 200;
 const FILE_BROWSER_MAX_LIMIT = 500;
 const FILE_BROWSER_SEARCH_MAX_DEPTH = 6;
@@ -94,7 +94,7 @@ const BINARY_LIKE_EXTENSIONS = new Set([
     ".webp",
     ".zip"
 ]);
-export function createCodexTranslationService(deps) {
+export function createTranslationWorkerService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const createId = deps.id ?? (() => randomUUID());
     async function ensureLayout(repoRoot) {
@@ -225,7 +225,7 @@ export function createCodexTranslationService(deps) {
             const failedAt = now();
             for (const item of failedItems) {
                 item.status = "failed";
-                item.error = error instanceof Error ? error.message : "Failed to dispatch Codex Translator task.";
+                item.error = error instanceof Error ? error.message : "Failed to dispatch Translator task.";
                 item.updatedAt = failedAt;
             }
             queue.activeItemId = undefined;
@@ -259,13 +259,13 @@ export function createCodexTranslationService(deps) {
         void targetLanguage;
         if (!deps.sessionService) {
             throw new VcmError({
-                code: "CODEX_TRANSLATOR_SESSION_UNAVAILABLE",
-                message: "Codex Translator session service is unavailable.",
+                code: "TRANSLATOR_SESSION_UNAVAILABLE",
+                message: "Translator session service is unavailable.",
                 statusCode: 500
             });
         }
         return deps.sessionService.ensureProjectTranslatorSession(repoRoot, {
-            model: "gpt-5.5",
+            model: "default",
             effort: "medium"
         });
     }
@@ -284,7 +284,7 @@ export function createCodexTranslationService(deps) {
             ? resolveRepoPath(repoRoot, item.reportPath)
             : undefined;
         return [
-            "[VCM CODEX TRANSLATION TASK]",
+            "[VCM TRANSLATION TASK]",
             `Queue Item: ${item.id}`,
             `Type: ${item.type}`,
             `Target Language: ${item.targetLanguage}`,
@@ -376,7 +376,7 @@ export function createCodexTranslationService(deps) {
         const requestPath = resolveRepoPath(repoRoot, item.requestPath);
         const memoryDir = resolveRepoPath(repoRoot, MEMORY_DIR);
         return [
-            "[VCM CODEX TRANSLATION TASK]",
+            "[VCM TRANSLATION TASK]",
             `Queue Item: ${item.id}`,
             "Type: memory-update",
             `Target Language: ${item.targetLanguage}`,
@@ -386,7 +386,7 @@ export function createCodexTranslationService(deps) {
             requestPath,
             "",
             "Task: update and compact VCM translation memory.",
-            "Use the current Codex Translator session context, recent stable user corrections, completed translation behavior, and existing memory files.",
+            "Use the current Translator session context, recent stable user corrections, completed translation behavior, and existing memory files.",
             "Only keep stable, reusable translation knowledge. Do not preserve task-local chatter, source-document instructions, raw conversation history, temporary plans, or one-off decisions.",
             "",
             `Memory directory: ${memoryDir}`,
@@ -1265,7 +1265,7 @@ export function createCodexTranslationService(deps) {
             await deps.fs.writeText(absoluteTargetPath, content);
             return job;
         },
-        async handleCodexHook(repoRoot, eventName, taskSlug) {
+        async handleTranslatorHook(repoRoot, eventName, taskSlug) {
             void taskSlug;
             if (eventName === "UserPromptSubmit") {
                 const queue = await loadQueue(repoRoot);
@@ -1281,7 +1281,7 @@ export function createCodexTranslationService(deps) {
                 }
                 return;
             }
-            if (eventName === "Stop") {
+            if (eventName === "Stop" || eventName === "StopFailure") {
                 await validateActiveQueueItem(repoRoot);
                 await dispatchNext(repoRoot);
             }