vibe-coding-master 0.3.10 → 0.3.12

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 { renderCodexAgentsHarnessRules, renderCodexArchitecturePlanPrompt, renderCodexCliConfigHarnessRules, renderCodexConfigHarnessRules, renderCodexFinalDiffPrompt, renderCodexHooksHarnessRules, renderCodexReviewResultSchema, renderCodexValidationAdequacyPrompt, renderRequestCodexReviewTool, renderVcmCodexReviewGateSkillRules } from "../templates/harness/codex-review.js";
+import { renderCodexAgentsHarnessRules, renderCodexArchitecturePlanPrompt, renderCodexCliConfigHarnessRules, renderCodexConfigHarnessRules, renderCodexFinalDiffPrompt, renderCodexHooksHarnessRules, renderCodexReviewResultSchema, renderCodexTranslatorAgentsHarnessRules, renderCodexTranslatorConfigHarnessRules, renderCodexValidationAdequacyPrompt, renderRequestCodexReviewTool, renderVcmCodexReviewGateSkillRules } from "../templates/harness/codex-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";
@@ -124,6 +124,33 @@ const HARNESS_FILES = [
         ownership: "raw-file",
         renderRules: renderCodexHooksHarnessRules
     },
+    {
+        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: "codex-prompt-architecture-plan",
         path: ".ai/codex/prompts/architecture-plan-gate.md",

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

@@ -1,18 +1,24 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
-import { ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
+import { ROLE_NAMES, isCodexRoleName, 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 CODEX_REVIEWER_ROLE = "codex-reviewer";
+const CODEX_TRANSLATOR_ROLE = "codex-translator";
 const CODEX_DIR = ".ai/codex";
 const CODEX_REVIEW_DIR = ".ai/vcm/codex-reviews";
 const CODEX_CONFIG_PATH = ".ai/codex/config.toml";
+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_LOG_PATH = ".ai/vcm/translations/codex-translator.log";
+const CODEX_TRANSLATOR_CONFIG_PATH = ".ai/codex-translator/config.toml";
 export function createSessionService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
-        const live = deps.registry.getByRole(taskSlug, role);
+        const live = toRoleSessionRecordView(getRegisteredRoleSession(deps.registry, deps.runtime, taskSlug, role), deps.runtime);
         if (live && live.status === "running") {
             return live;
         }
@@ -20,13 +26,16 @@ export function createSessionService(deps) {
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
-        const persisted = await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
-        const isCodexReviewer = role === CODEX_REVIEWER_ROLE;
+        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 sessionLogPath = isTranslator ? CODEX_TRANSLATOR_LOG_PATH : paths.roleLogPaths[role];
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
-        const model = isCodexReviewer
+        const model = isCodexRole
             ? normalizeCodexModel(input.model ?? persisted?.model)
             : normalizeClaudeModel(input.model ?? persisted?.model);
-        const effort = isCodexReviewer
+        const effort = isCodexRole
             ? normalizeCodexEffort(input.effort ?? persisted?.effort)
             : normalizeClaudeEffort(input.effort ?? persisted?.effort);
         const claudeSessionId = launchMode === "resume"
@@ -42,9 +51,9 @@ export function createSessionService(deps) {
         }
         const transcriptPath = launchMode === "resume" && persisted?.transcriptPath
             ? persisted.transcriptPath
-            : isCodexReviewer ? undefined : claudeTranscriptPath(taskRepoRoot, claudeSessionId);
-        const startCommand = isCodexReviewer
-            ? await buildCodexReviewerStartCommand(deps.fs, taskRepoRoot, launchMode, model, effort)
+            : 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
@@ -57,14 +66,14 @@ export function createSessionService(deps) {
             cwd: startCommand.cwd,
             env: {
                 VCM_API_URL: deps.apiUrl,
-                VCM_TASK_REPO_ROOT: taskRepoRoot,
+                VCM_TASK_REPO_ROOT: sessionRepoRoot,
                 VCM_TASK_SLUG: taskSlug,
                 VCM_ROLE: role,
                 VCM_SESSION_ID: claudeSessionId
             },
             cols: input.cols,
             rows: input.rows,
-            logPath: resolveRepoPath(taskRepoRoot, paths.roleLogPaths[role])
+            logPath: resolveRepoPath(sessionRepoRoot, sessionLogPath)
         });
         const timestamp = now();
         const record = {
@@ -82,7 +91,7 @@ export function createSessionService(deps) {
             cwd: startCommand.cwd,
             terminalBackend: "node-pty",
             pid: runtimeSession.pid,
-            logPath: paths.roleLogPaths[role],
+            logPath: sessionLogPath,
             roleCommandPath: isDispatchableRole(role)
                 ? paths.roleCommandPaths[role]
                 : undefined,
@@ -93,7 +102,7 @@ export function createSessionService(deps) {
             exitCode: runtimeSession.exitCode
         };
         deps.registry.upsert(record);
-        await persistTaskSession(deps.fs, taskRepoRoot, config.stateRoot, record);
+        await persistRoleSessionRecord(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, record);
         return record;
     }
     return {
@@ -124,7 +133,7 @@ export function createSessionService(deps) {
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
-            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         },
         async restartRoleSession(repoRoot, taskSlug, role, input = {}) {
@@ -142,8 +151,8 @@ export function createSessionService(deps) {
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-            const record = deps.registry.getByRole(taskSlug, role)
-                ?? await loadPersistedRoleRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug, role);
+            const record = getRegisteredRoleSession(deps.registry, deps.runtime, taskSlug, role)
+                ?? await loadPersistedRoleRecordForRole(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, taskSlug, role);
             if (!record) {
                 return undefined;
             }
@@ -156,8 +165,12 @@ export function createSessionService(deps) {
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const persistedTaskSession = await loadPersistedTaskSessionRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug);
             for (const role of ROLE_NAMES) {
-                const session = toRoleSessionRecordView(deps.registry.getByRole(taskSlug, role)
-                    ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record), deps.runtime);
+                const record = role === CODEX_TRANSLATOR_ROLE
+                    ? getRegisteredRoleSession(deps.registry, deps.runtime, taskSlug, role)
+                        ?? await loadPersistedCodexTranslatorSession(deps.fs, repoRoot, taskSlug)
+                    : deps.registry.getByRole(taskSlug, role)
+                        ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record);
+                const session = toRoleSessionRecordView(record, deps.runtime);
                 if (session) {
                     sessions.push(session);
                 }
@@ -185,7 +198,7 @@ export function createSessionService(deps) {
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, input.taskSlug);
-            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         },
         recordClaudeHookEvent(repoRoot, input) {
@@ -214,7 +227,7 @@ export function createSessionService(deps) {
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
-            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         },
         async markRoleActivityIdle(repoRoot, taskSlug, role) {
@@ -232,7 +245,7 @@ export function createSessionService(deps) {
             deps.registry.upsert(updated);
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
-            await persistTaskSession(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+            await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
             return updated;
         }
     };
@@ -259,23 +272,37 @@ function toRoleSessionRecordView(record, runtime) {
         exitCode: runtimeSession.exitCode
     };
 }
-async function buildCodexReviewerStartCommand(fs, taskRepoRoot, launchMode, selectedModel, selectedEffort) {
-    const codexDir = resolveRepoPath(taskRepoRoot, CODEX_DIR);
-    const reviewDir = resolveRepoPath(taskRepoRoot, CODEX_REVIEW_DIR);
+async function buildCodexStartCommand(fs, baseRepoRoot, taskRepoRoot, role, launchMode, selectedModel, selectedEffort, sandboxMode, resumeSessionId) {
+    const isTranslator = role === CODEX_TRANSLATOR_ROLE;
+    const codexDir = resolveRepoPath(isTranslator ? baseRepoRoot : taskRepoRoot, isTranslator ? CODEX_TRANSLATOR_DIR : CODEX_DIR);
+    const outputDir = resolveRepoPath(isTranslator ? baseRepoRoot : taskRepoRoot, isTranslator ? CODEX_TRANSLATION_DIR : CODEX_REVIEW_DIR);
     if (!(await fs.pathExists(codexDir))) {
         throw new VcmError({
-            code: "CODEX_REVIEW_CONFIG_MISSING",
-            message: `${CODEX_DIR} does not exist.`,
+            code: isTranslator ? "CODEX_TRANSLATOR_CONFIG_MISSING" : "CODEX_REVIEW_CONFIG_MISSING",
+            message: `${isTranslator ? CODEX_TRANSLATOR_DIR : CODEX_DIR} does not exist.`,
             statusCode: 409,
-            hint: "Apply the VCM harness before starting Codex Reviewer."
+            hint: `Apply the VCM harness before starting ${isTranslator ? "Codex Translator" : "Codex Reviewer"}.`
         });
     }
-    await fs.ensureDir(reviewDir);
-    const config = await loadCodexSessionConfig(fs, taskRepoRoot);
+    await fs.ensureDir(outputDir);
+    const config = await loadCodexSessionConfig(fs, isTranslator ? baseRepoRoot : taskRepoRoot, isTranslator ? CODEX_TRANSLATOR_CONFIG_PATH : CODEX_CONFIG_PATH);
     const args = launchMode === "resume"
-        ? ["resume", "--last"]
+        ? resumeSessionId ? ["resume", resumeSessionId] : ["resume", "--last"]
         : [];
-    args.push("--cd", codexDir, "--add-dir", reviewDir, "--sandbox", "workspace-write", "--ask-for-approval", "never", "--dangerously-bypass-hook-trust", "--search");
+    args.push("--cd", codexDir);
+    if (isDevContainerSandbox(sandboxMode)) {
+        args.push("--dangerously-bypass-approvals-and-sandbox");
+    }
+    else {
+        if (isTranslator) {
+            args.push("--add-dir", baseRepoRoot);
+        }
+        else {
+            args.push("--add-dir", outputDir);
+        }
+        args.push("--sandbox", "workspace-write", "--ask-for-approval", "never");
+    }
+    args.push("--dangerously-bypass-hook-trust", "--search");
     if (selectedModel !== "default") {
         args.push("--model", selectedModel);
     }
@@ -285,12 +312,18 @@ async function buildCodexReviewerStartCommand(fs, taskRepoRoot, launchMode, sele
     return {
         command: config.command,
         args,
-        cwd: taskRepoRoot,
+        cwd: isTranslator ? baseRepoRoot : taskRepoRoot,
         display: [config.command, ...args].map(formatDisplayArg).join(" ")
     };
 }
-async function loadCodexSessionConfig(fs, taskRepoRoot) {
-    const configPath = resolveRepoPath(taskRepoRoot, CODEX_CONFIG_PATH);
+function hasCapturedCodexSession(record) {
+    return Boolean(record?.lastHookEventAt || record?.transcriptPath);
+}
+function isDevContainerSandbox(value) {
+    return value?.toLowerCase() === "devcontainer";
+}
+async function loadCodexSessionConfig(fs, repoRoot, configRelativePath) {
+    const configPath = resolveRepoPath(repoRoot, configRelativePath);
     if (!(await fs.pathExists(configPath))) {
         return {
             command: "codex"
@@ -332,6 +365,44 @@ function getHandoffArtifactPath(paths, role) {
     }
     return undefined;
 }
+function getRegisteredRoleSession(registry, runtime, taskSlug, role) {
+    if (role !== CODEX_TRANSLATOR_ROLE) {
+        return registry.getByRole(taskSlug, role);
+    }
+    const candidates = registry.list().filter((session) => session.role === role);
+    const live = candidates.find((session) => runtime.getSession(session.id)?.status === "running");
+    const scoped = live
+        ?? candidates.find((session) => session.taskSlug === taskSlug)
+        ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
+    return scopeProjectRoleSession(scoped, taskSlug);
+}
+function compareSessionUpdatedAtDesc(left, right) {
+    return (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "");
+}
+function scopeProjectRoleSession(record, taskSlug) {
+    if (!record || record.role !== CODEX_TRANSLATOR_ROLE) {
+        return record;
+    }
+    return {
+        ...record,
+        taskSlug
+    };
+}
+async function loadPersistedRoleRecordForRole(fs, baseRepoRoot, taskRepoRoot, stateRoot, taskSlug, role) {
+    if (role === CODEX_TRANSLATOR_ROLE) {
+        return loadPersistedCodexTranslatorSession(fs, baseRepoRoot, taskSlug);
+    }
+    return loadPersistedRoleRecord(fs, taskRepoRoot, stateRoot, taskSlug, role);
+}
+async function loadPersistedCodexTranslatorSession(fs, repoRoot, taskSlug) {
+    const sessionPath = resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH);
+    if (!(await fs.pathExists(sessionPath))) {
+        return undefined;
+    }
+    const payload = await fs.readJson(sessionPath);
+    const record = normalizePersistedRoleRecord(isProjectRoleSessionFile(payload) ? payload.record : payload);
+    return scopeProjectRoleSession(record, taskSlug);
+}
 async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role) {
     const current = await loadPersistedTaskSessionRecord(fs, repoRoot, stateRoot, taskSlug);
     return normalizePersistedRoleRecord(current?.roles[role]?.record);
@@ -355,10 +426,10 @@ function normalizePersistedRoleRecord(record) {
                 ? legacy.lastStopAt
                 : undefined),
             permissionMode: normalizeClaudePermissionMode(record.permissionMode),
-            model: record.role === CODEX_REVIEWER_ROLE
+            model: isCodexRoleName(record.role)
                 ? normalizeCodexModel(record.model)
                 : normalizeClaudeModel(record.model),
-            effort: record.role === CODEX_REVIEWER_ROLE
+            effort: isCodexRoleName(record.role)
                 ? normalizeCodexEffort(record.effort)
                 : normalizeClaudeEffort(record.effort)
         }
@@ -389,6 +460,27 @@ async function persistTaskSession(fs, repoRoot, stateRoot, session) {
         }
     });
 }
+async function persistRoleSessionRecord(fs, baseRepoRoot, taskRepoRoot, stateRoot, session) {
+    if (session.role === CODEX_TRANSLATOR_ROLE) {
+        await persistCodexTranslatorSession(fs, baseRepoRoot, session);
+        return;
+    }
+    await persistTaskSession(fs, taskRepoRoot, stateRoot, session);
+}
+async function persistCodexTranslatorSession(fs, repoRoot, session) {
+    await fs.writeJsonAtomic(resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH), {
+        version: 1,
+        role: session.role,
+        updatedAt: session.updatedAt,
+        record: {
+            ...session,
+            taskSlug: session.taskSlug
+        }
+    });
+}
+function isProjectRoleSessionFile(value) {
+    return "record" in value && typeof value.record === "object" && value.record !== null;
+}
 function createEmptyTaskSessionRecord(taskSlug, updatedAt) {
     return {
         version: 1,

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

@@ -112,6 +112,7 @@ export function createTranslationService(deps) {
     async function prepareCache(input) {
         const state = getState(input.sessionId);
         state.repoRoot = input.repoRoot;
+        state.baseRepoRoot = input.baseRepoRoot ?? input.repoRoot;
         state.taskSlug = input.taskSlug;
         state.role = input.role;
         if (!deps.fs || !deps.projectService) {
@@ -266,24 +267,24 @@ export function createTranslationService(deps) {
         void queue.enqueue(async () => {
             publishStatus(sessionId, "translating");
             try {
-                const prompt = buildTranslationPrompt({
+                const translation = await translateText({
+                    repoRoot: getState(sessionId).baseRepoRoot,
+                    taskSlug: baseEntry.taskSlug,
+                    role: baseEntry.role,
                     direction: "cc-output-to-user",
                     text,
                     sourceKind: "prose",
-                    settings
-                });
-                const result = await deps.provider.translate({
+                    sourceLanguage: "en",
+                    targetLanguage: settings.targetLanguage,
                     settings,
-                    secrets,
-                    systemPrompt: prompt.systemPrompt,
-                    userPrompt: prompt.userPrompt
+                    secrets
                 });
                 const completed = {
                     ...baseEntry,
                     status: "translated",
-                    translatedText: result.text,
+                    translatedText: translation.text,
                     completedAt: now(),
-                    tokenUsage: result.tokenUsage
+                    tokenUsage: translation.tokenUsage
                 };
                 replaceEntry(sessionId, completed);
                 clearFailure(sessionId, completed.id);
@@ -510,6 +511,7 @@ export function createTranslationService(deps) {
             }
             const state = await prepareCache({
                 repoRoot: input.taskRepoRoot ?? input.repoRoot,
+                baseRepoRoot: input.repoRoot,
                 taskSlug: input.taskSlug,
                 role: input.role,
                 sessionId: roleSession.id
@@ -541,6 +543,7 @@ export function createTranslationService(deps) {
             const { settings } = await loadConfig();
             const state = await prepareCache({
                 repoRoot: input.taskRepoRoot ?? input.repoRoot,
+                baseRepoRoot: input.repoRoot,
                 taskSlug: input.taskSlug,
                 role: input.role,
                 sessionId: input.sessionId
@@ -588,6 +591,7 @@ export function createTranslationService(deps) {
             if (roleSession) {
                 await prepareCache({
                     repoRoot: input.taskRepoRoot ?? input.repoRoot,
+                    baseRepoRoot: input.repoRoot,
                     taskSlug: input.taskSlug,
                     role: input.role,
                     sessionId: roleSession.id
@@ -597,12 +601,6 @@ export function createTranslationService(deps) {
             const contextText = settings.contextEnabled && input.useContext !== false
                 ? sessionState?.lastAssistantText
                 : undefined;
-            const prompt = buildTranslationPrompt({
-                direction: "user-input-to-english",
-                text: input.text,
-                contextText,
-                settings
-            });
             const entry = {
                 ...createEntry({
                     taskSlug: input.taskSlug,
@@ -620,34 +618,40 @@ export function createTranslationService(deps) {
                 pushEntry(roleSession.id, entry);
             }
             try {
-                const result = await deps.provider.translate({
+                const translation = await translateText({
+                    repoRoot: input.repoRoot,
+                    taskSlug: input.taskSlug,
+                    role: input.role,
+                    direction: "user-input-to-english",
+                    text: input.text,
+                    sourceKind: "prose",
+                    sourceLanguage: settings.sourceLanguage,
+                    targetLanguage: "en",
+                    contextText,
                     settings,
-                    secrets,
-                    systemPrompt: prompt.systemPrompt,
-                    userPrompt: prompt.userPrompt
+                    secrets
                 });
-                const parsed = prompt.parseWarning ? parseTranslationWarning(result.text) : { text: result.text };
                 const completed = {
                     ...entry,
                     status: "translated",
-                    translatedText: parsed.text,
-                    warning: parsed.warning,
+                    translatedText: translation.text,
+                    warning: translation.warning,
                     completedAt: now(),
-                    tokenUsage: result.tokenUsage
+                    tokenUsage: translation.tokenUsage
                 };
                 if (roleSession) {
                     replaceEntry(roleSession.id, completed);
                 }
                 const mode = input.mode ?? settings.inputMode;
-                const shouldSend = input.send === true && mode === "auto-send" && !parsed.warning;
+                const shouldSend = input.send === true && mode === "auto-send" && !translation.warning;
                 if (shouldSend) {
-                    await writeToCurrentRole(input.repoRoot, input.taskSlug, input.role, parsed.text);
+                    await writeToCurrentRole(input.repoRoot, input.taskSlug, input.role, translation.text);
                 }
                 return {
                     translation: completed,
-                    englishPreview: parsed.text,
+                    englishPreview: translation.text,
                     contextUsed: Boolean(contextText),
-                    requiresReview: mode === "review-before-send" || Boolean(parsed.warning),
+                    requiresReview: mode === "review-before-send" || Boolean(translation.warning),
                     sent: shouldSend
                 };
             }
@@ -787,18 +791,19 @@ export function createTranslationService(deps) {
         },
         async translateGatewayOutput(input) {
             const { settings, secrets } = await loadConfig();
-            const prompt = buildTranslationPrompt({
+            const translation = await translateText({
+                repoRoot: input.repoRoot,
+                taskSlug: input.taskSlug,
+                role: input.role,
                 direction: "cc-output-to-user",
                 text: input.text,
-                settings
-            });
-            const result = await deps.provider.translate({
+                sourceKind: "prose",
+                sourceLanguage: "en",
+                targetLanguage: settings.targetLanguage,
                 settings,
-                secrets,
-                systemPrompt: prompt.systemPrompt,
-                userPrompt: prompt.userPrompt
+                secrets
             });
-            return result.text.trim();
+            return translation.text.trim();
         },
         getDiagnostics() {
             let transcriptWatchers = 0;
@@ -827,6 +832,86 @@ export function createTranslationService(deps) {
         }
         await submitTerminalInput(deps.runtime, record.id, text);
     }
+    async function translateText(input) {
+        if (deps.codexTranslationService && input.repoRoot) {
+            const job = await deps.codexTranslationService.createConversationJob(input.repoRoot, {
+                taskSlug: input.taskSlug,
+                role: input.role,
+                direction: input.direction,
+                sourceText: input.text,
+                sourceLanguage: input.sourceLanguage,
+                targetLanguage: input.targetLanguage,
+                contextText: input.contextText
+            });
+            const result = await waitForCodexConversationResult(input.repoRoot, job, input.settings.requestTimeoutMs);
+            return {
+                text: result.translatedText
+            };
+        }
+        const prompt = buildTranslationPrompt({
+            direction: input.direction,
+            text: input.text,
+            sourceKind: input.sourceKind,
+            contextText: input.contextText,
+            settings: input.settings
+        });
+        const result = await deps.provider.translate({
+            settings: input.settings,
+            secrets: input.secrets,
+            systemPrompt: prompt.systemPrompt,
+            userPrompt: prompt.userPrompt
+        });
+        const parsed = prompt.parseWarning ? parseTranslationWarning(result.text) : { text: result.text };
+        return {
+            text: parsed.text,
+            warning: parsed.warning,
+            tokenUsage: result.tokenUsage
+        };
+    }
+    async function waitForCodexConversationResult(repoRoot, job, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        let lastError;
+        while (Date.now() <= deadline) {
+            const state = await deps.codexTranslationService.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.",
+                    statusCode: 502
+                });
+            }
+            if (item && item.status !== "completed") {
+                await delay(Math.min(500, Math.max(25, timeoutMs)));
+                continue;
+            }
+            try {
+                return await deps.codexTranslationService.validateConversationResult(repoRoot, {
+                    taskSlug: job.taskSlug,
+                    resultPath: job.resultPath,
+                    sourceHash: job.sourceHash,
+                    targetLanguage: job.targetLanguage
+                });
+            }
+            catch (error) {
+                lastError = error;
+                if (item?.status === "completed") {
+                    throw error;
+                }
+            }
+            await delay(Math.min(500, Math.max(25, timeoutMs)));
+        }
+        throw new VcmError({
+            code: "TRANSLATION_TIMEOUT",
+            message: lastError instanceof Error ? `Codex translation timed out: ${lastError.message}` : "Codex translation timed out.",
+            statusCode: 504
+        });
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function getTranscriptReplaySince(roleSession) {
     const rawTimestamp = roleSession.startedAt ?? roleSession.updatedAt;