vibe-coding-master 0.3.22 → 0.3.24

package/README.md

@@ -237,7 +237,7 @@ the base repo has uncommitted changes, when the current branch has no upstream,
 or when the active task is an inline task using the base repo directly. It does
 not stash, merge, or mutate task worktrees.
 
-When VCM is connected to an active task, the bottom of the sidebar shows a task status dock. It stays outside the collapsible groups and shows the active VCM Session title, task status, start time, total elapsed time, total Round count, and role active runtime. If a Round is currently running, the dock also shows the Current Round start time, total elapsed time, role active runtime, and Turn count.
+When VCM is connected to an active task, the bottom of the sidebar shows a task status dock. It stays outside the collapsible groups and shows the active VCM Session title, task status, start time, total elapsed time, total Round count, and role active runtime. The dock also shows the Current Round while it is running, or the Last Round after a flow pause, including start time, total elapsed time, role active runtime, Turn count, and Round status.
 
 ## Mobile Gateway
 
@@ -586,7 +586,7 @@ The normal path is timer-driven: `Stop` starts a backend timer, and `UserPromptS
 
 When `Flow pause alert` is enabled, the frontend polls the task Round state and deduplicates each stopped Round so the same stopped state does not alert on every poll. Flow duration is measured from the first `UserPromptSubmit` to `stoppedAt`, falling back to the last `Stop` when needed. If the flow lasted less than 2 minutes, it plays the local chime 3 times at 1.4 second intervals. If the flow lasted 2 minutes or longer, it shows a modal alert and repeats the local chime until the user clicks `Confirm`. A stopped Round can mean normal completion, user decision needed, dispatch failure, or another workflow interruption; the point is to get the user to look with the right amount of urgency.
 
-The Current Round dock separates wall-clock Round duration from role active runtime. `Total` is `now - Round.startedAt`; `Role runtime` is only the accumulated time between each Turn's `UserPromptSubmit` and `Stop`; `Turn count` is the number of accepted prompts inside the current Round.
+The Round dock separates wall-clock Round duration from role active runtime. For a running Round, `Total` is `now - Round.startedAt`; for a stopped Round, it is `stoppedAt - Round.startedAt`. `Role runtime` is only the accumulated time between each Turn's `UserPromptSubmit` and `Stop`; `Turn count` is the number of accepted prompts inside the Round.
 
 ## Resume Behavior
 

package/dist/backend/adapters/git-adapter.js

@@ -81,6 +81,18 @@ export function createGitAdapter(runner) {
             }
             return result.stdout;
         },
+        async getStagedStatus(repoRoot) {
+            const result = await runGit(runner, repoRoot, ["diff", "--cached", "--name-status"]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_ERROR",
+                    message: "Unable to read staged Git changes.",
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+            return result.stdout;
+        },
         async isIgnored(repoRoot, repoRelativePath) {
             const result = await runGit(runner, repoRoot, ["check-ignore", "-q", "--", repoRelativePath]);
             if (result.exitCode === 0) {
@@ -111,6 +123,47 @@ export function createGitAdapter(runner) {
                 hint: result.stderr
             });
         },
+        async addPaths(repoRoot, paths) {
+            if (paths.length === 0) {
+                return;
+            }
+            const result = await runGit(runner, repoRoot, ["add", "--", ...paths]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_ADD_FAILED",
+                    message: "Unable to stage harness changes.",
+                    statusCode: 409,
+                    hint: result.stderr || result.stdout
+                });
+            }
+        },
+        async commit(repoRoot, message) {
+            const result = await runGit(runner, repoRoot, ["commit", "-m", message]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_COMMIT_FAILED",
+                    message: "Unable to commit harness changes.",
+                    statusCode: 409,
+                    hint: result.stderr || result.stdout
+                });
+            }
+            return this.getHeadCommit(repoRoot);
+        },
+        async rebase(repoRoot, upstream) {
+            const result = await runGit(runner, repoRoot, ["rebase", upstream]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_REBASE_FAILED",
+                    message: "Unable to rebase task branch onto the harness commit.",
+                    statusCode: 409,
+                    hint: result.stderr || result.stdout
+                });
+            }
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
+        },
         async createWorktree(input) {
             const result = await runGit(runner, input.repoRoot, [
                 "worktree",

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

@@ -1,4 +1,4 @@
-import { isDispatchableRole, isRoleName } from "../../shared/constants.js";
+import { isDispatchableRole } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerArtifactRoutes(app, deps) {
@@ -52,33 +52,6 @@ export function registerArtifactRoutes(app, deps) {
         });
         return { ok: true };
     });
-    app.get("/api/tasks/:taskSlug/logs/:role", async (request) => {
-        const project = await requireCurrentProject(deps.projectService);
-        if (!isRoleName(request.params.role)) {
-            throw new VcmError({
-                code: "UNKNOWN_ROLE",
-                message: `Unknown role: ${request.params.role}`,
-                statusCode: 400
-            });
-        }
-        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
-        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-        const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
-        const artifactPath = paths.roleLogPaths[request.params.role];
-        if (!artifactPath) {
-            return {
-                role: request.params.role,
-                content: ""
-            };
-        }
-        return {
-            role: request.params.role,
-            content: await deps.artifactService.readArtifact({
-                repoRoot: taskRepoRoot,
-                artifactPath
-            })
-        };
-    });
 }
 function parseDispatchableRole(role) {
     if (!isDispatchableRole(role)) {

package/dist/backend/api/codex-translation-routes.js

@@ -4,6 +4,30 @@ export function registerCodexTranslationRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.codexTranslationService.getState(project.repoRoot);
     });
+    app.get("/api/translation/codex/session", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return (await deps.sessionService.getProjectTranslatorSession(project.repoRoot)) ?? null;
+    });
+    app.post("/api/translation/codex/session/ensure", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.ensureProjectTranslatorSession(project.repoRoot, request.body);
+    });
+    app.post("/api/translation/codex/session/start", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.startProjectTranslatorSession(project.repoRoot, request.body);
+    });
+    app.post("/api/translation/codex/session/resume", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.resumeProjectTranslatorSession(project.repoRoot, request.body);
+    });
+    app.post("/api/translation/codex/session/restart", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.restartProjectTranslatorSession(project.repoRoot, request.body);
+    });
+    app.post("/api/translation/codex/session/stop", async () => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.sessionService.stopProjectTranslatorSession(project.repoRoot);
+    });
     app.get("/api/translation/codex/source-files", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         return deps.codexTranslationService.browseSourceFiles(project.repoRoot, {

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

@@ -16,6 +16,16 @@ export function registerHarnessRoutes(app, deps) {
         const project = await requireCurrentProject(deps.projectService);
         return deps.harnessService.applyHarness(project.repoRoot);
     });
+    app.post("/api/projects/harness/tasks/:taskSlug/commit-and-rebase", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        return deps.harnessService.commitAndRebaseTask(project.repoRoot, {
+            taskSlug: task.taskSlug,
+            branch: task.branch,
+            worktreePath: task.worktreePath,
+            changedFiles: request.body?.changedFiles ?? []
+        });
+    });
     app.get("/api/projects/harness/bootstrap", async () => {
         const project = await requireCurrentProject(deps.projectService);
         try {

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

@@ -1,4 +1,4 @@
-import { DISPATCHABLE_ROLES, ROLE_NAMES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
 import { isOpenFileLimitError, VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerTaskRoutes(app, deps) {
@@ -66,6 +66,7 @@ function degradedTaskStatus(repoRoot, taskSlug, error) {
             createdAt: timestamp,
             updatedAt: timestamp,
             repoRoot,
+            worktreePath: `${repoRoot}/.claude/worktrees/${taskSlug}`,
             branch: "unknown",
             handoffDir,
             status: "stopped"
@@ -79,18 +80,13 @@ function degradedTaskStatus(repoRoot, taskSlug, error) {
 }
 function degradedArtifactSummary(handoffDir) {
     const roleCommandsDir = `${handoffDir}/role-commands`;
-    const logsDir = `${handoffDir}/logs`;
     const messagesDir = `${handoffDir}/messages`;
     return {
         paths: {
             handoffDir,
             roleCommandsDir,
-            logsDir,
             messagesDir,
             roleCommandPaths: Object.fromEntries(DISPATCHABLE_ROLES.map((role) => [role, `${roleCommandsDir}/${role}.md`])),
-            roleLogPaths: Object.fromEntries(ROLE_NAMES
-                .filter((role) => role !== "codex-translator")
-                .map((role) => [role, `${logsDir}/${role}.log`])),
             messageRoutePaths: {},
             architecturePlanPath: `${handoffDir}/architecture-plan.md`,
             knownIssuesPath: `${handoffDir}/known-issues.md`,

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

@@ -352,17 +352,6 @@ export function createGatewayService(deps) {
     }
     async function pullCurrent() {
         const project = await ensureProject();
-        const settings = await syncDesktopContext(await deps.settings.loadSettings());
-        if (settings.currentTaskSlug) {
-            const task = await deps.taskService.loadTask(project.repoRoot, settings.currentTaskSlug);
-            if (!task.worktreePath && task.cleanupStatus !== "cleaned") {
-                throw new VcmError({
-                    code: "GATEWAY_PULL_BLOCKED_BY_INLINE_TASK",
-                    message: `Inline task "${task.taskSlug}" uses the base repository.`,
-                    statusCode: 409
-                });
-            }
-        }
         const pulled = await deps.projectService.pullCurrentProject();
         return [
             "Connected repository updated.",
@@ -377,7 +366,7 @@ export function createGatewayService(deps) {
         if (tasks.length === 0) {
             return "No tasks. Use /create-task <task-slug> [title] to create one.";
         }
-        return tasks.map((task, index) => `${index + 1}. ${task.taskSlug} [${task.status}] ${task.worktreePath ? "worktree" : "inline"}`).join("\n");
+        return tasks.map((task, index) => `${index + 1}. ${task.taskSlug} [${task.status}] ${task.branch}`).join("\n");
     }
     async function useTask(selector) {
         const project = await ensureProject();
@@ -405,8 +394,7 @@ export function createGatewayService(deps) {
         const project = await ensureProject();
         const task = await deps.taskService.createTask(project.repoRoot, {
             taskSlug,
-            title,
-            createWorktree: true
+            title
         });
         const config = await deps.projectService.loadConfig(project.repoRoot);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
@@ -460,7 +448,7 @@ export function createGatewayService(deps) {
         return [
             `Task created and initialized: ${task.taskSlug}`,
             `branch: ${task.branch}`,
-            `worktree: ${task.worktreePath ?? task.repoRoot}`,
+            `worktree: ${task.worktreePath}`,
             `orchestration: ${template.autoOrchestration ? "auto" : "manual"}`,
             `translation: ${preferences.translationEnabled ? "on" : "off"}`,
             `sessions: ${startedRoles.join(", ")}`
@@ -523,7 +511,6 @@ export function createGatewayService(deps) {
         deps.roundService.stopTask(taskSlug);
         const result = await deps.taskService.cleanupTask(project.repoRoot, taskSlug, {
             force: true,
-            deleteBranch: Boolean(task.worktreePath),
             forceDeleteBranch: true
         });
         clearFailedTranslation(project.repoRoot, taskSlug);

package/dist/backend/server.js

@@ -73,7 +73,8 @@ export async function createServer(deps, options = {}) {
     });
     registerCodexTranslationRoutes(app, {
         projectService: deps.projectService,
-        codexTranslationService: deps.codexTranslationService
+        codexTranslationService: deps.codexTranslationService,
+        sessionService: deps.sessionService
     });
     registerProjectRoutes(app, {
         projectService: deps.projectService,
@@ -81,7 +82,8 @@ export async function createServer(deps, options = {}) {
     });
     registerHarnessRoutes(app, {
         projectService: deps.projectService,
-        harnessService: deps.harnessService
+        harnessService: deps.harnessService,
+        taskService: deps.taskService
     });
     registerTaskRoutes(app, {
         projectService: deps.projectService,
@@ -169,6 +171,7 @@ export function createDefaultServerDeps(options = {}) {
     const projectService = createProjectService({ fs, git, appSettings });
     const harnessService = createHarnessService({
         fs,
+        git,
         runtime,
         projectService,
         apiUrl: options.apiUrl,

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

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { DISPATCHABLE_ROLES, ROLE_NAMES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
 import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
@@ -25,25 +25,16 @@ export function createArtifactService(fs) {
     return {
         getHandoffPaths(_repoRoot, handoffDir) {
             const roleCommandsDir = path.posix.join(handoffDir, "role-commands");
-            const logsDir = path.posix.join(handoffDir, "logs");
             const messagesDir = path.posix.join(handoffDir, "messages");
             return {
                 handoffDir,
                 roleCommandsDir,
-                logsDir,
                 messagesDir,
                 roleCommandPaths: {
                     architect: path.posix.join(roleCommandsDir, "architect.md"),
                     coder: path.posix.join(roleCommandsDir, "coder.md"),
                     reviewer: path.posix.join(roleCommandsDir, "reviewer.md")
                 },
-                roleLogPaths: {
-                    "project-manager": path.posix.join(logsDir, "project-manager.log"),
-                    architect: path.posix.join(logsDir, "architect.log"),
-                    coder: path.posix.join(logsDir, "coder.log"),
-                    reviewer: path.posix.join(logsDir, "reviewer.log"),
-                    "codex-reviewer": path.posix.join(logsDir, "codex-reviewer.log")
-                },
                 messageRoutePaths: getDefaultMessageRoutePaths(messagesDir),
                 architecturePlanPath: path.posix.join(handoffDir, "architecture-plan.md"),
                 knownIssuesPath: path.posix.join(handoffDir, "known-issues.md"),
@@ -59,7 +50,6 @@ export function createArtifactService(fs) {
             const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
             await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.handoffDir));
             await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.roleCommandsDir));
-            await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.logsDir));
             await fs.ensureDir(resolveRepoPath(input.repoRoot, paths.messagesDir));
             return paths;
         },
@@ -168,25 +158,6 @@ export function createArtifactService(fs) {
         async saveRoleCommand(input) {
             const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
             await fs.writeText(resolveRepoPath(input.repoRoot, paths.roleCommandPaths[input.role]), input.content);
-        },
-        async appendRoleLog(input) {
-            if (!ROLE_NAMES.includes(input.role)) {
-                throw new VcmError({
-                    code: "UNKNOWN_ROLE",
-                    message: `Unknown role: ${input.role}`,
-                    statusCode: 400
-                });
-            }
-            const paths = this.getHandoffPaths(input.repoRoot, input.handoffDir);
-            const roleLogPath = paths.roleLogPaths[input.role];
-            if (!roleLogPath) {
-                throw new VcmError({
-                    code: "ROLE_LOG_UNAVAILABLE",
-                    message: `${input.role} does not write a handoff log.`,
-                    statusCode: 409
-                });
-            }
-            await fs.appendText(resolveRepoPath(input.repoRoot, roleLogPath), input.content);
         }
     };
 }

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

@@ -18,6 +18,13 @@ export function createCodexHookService(deps) {
                 statusCode: 409
             });
         }
+        if (input.role === "codex-translator") {
+            return {
+                project,
+                config: undefined,
+                taskRepoRoot: undefined
+            };
+        }
         const config = await deps.projectService.loadConfig(project.repoRoot);
         const task = await deps.taskService.loadTask(project.repoRoot, input.taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
@@ -37,16 +44,30 @@ export function createCodexHookService(deps) {
             });
         }
         const context = await getHookContext(input);
-        const session = await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
-            taskSlug: input.taskSlug,
-            role: input.role,
-            eventName,
-            sessionId: stringOrUndefined(input.event.session_id),
-            transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd),
-            allowSessionMismatch: true
-        });
+        const session = input.role === "codex-translator"
+            ? await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
+                eventName,
+                sessionId: stringOrUndefined(input.event.session_id),
+                transcriptPath: stringOrUndefined(input.event.transcript_path),
+                cwd: stringOrUndefined(input.event.cwd)
+            })
+            : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
+                taskSlug: input.taskSlug,
+                role: input.role,
+                eventName,
+                sessionId: stringOrUndefined(input.event.session_id),
+                transcriptPath: stringOrUndefined(input.event.transcript_path),
+                cwd: stringOrUndefined(input.event.cwd),
+                allowSessionMismatch: true
+            });
         if (input.role === "codex-reviewer") {
+            if (!context.config || !context.taskRepoRoot) {
+                throw new VcmError({
+                    code: "CODEX_HOOK_TASK_CONTEXT_MISSING",
+                    message: "Codex Reviewer hook is missing task context.",
+                    statusCode: 500
+                });
+            }
             await deps.roundService.recordRoleTurnEvent({
                 repoRoot: context.project.repoRoot,
                 stateRepoRoot: context.taskRepoRoot,

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

@@ -178,7 +178,7 @@ export function createCodexTranslationService(deps) {
         await saveQueue(repoRoot, queue);
         return queued;
     }
-    async function dispatchNext(repoRoot, taskSlug) {
+    async function dispatchNext(repoRoot) {
         if (!deps.runtime || !deps.sessionService) {
             return;
         }
@@ -207,7 +207,7 @@ export function createCodexTranslationService(deps) {
                 queue.updatedAt = next.updatedAt;
                 await saveQueue(repoRoot, queue);
             }
-            const session = await ensureTranslatorSession(repoRoot, taskSlug, next.targetLanguage);
+            const session = await ensureTranslatorSession(repoRoot, next.targetLanguage);
             await submitTerminalInput(deps.runtime, session.id, batch?.prompt ?? await buildQueuePrompt(repoRoot, next));
             const dispatchedAt = now();
             for (const item of batch?.items ?? [next]) {
@@ -255,7 +255,7 @@ export function createCodexTranslationService(deps) {
         await saveQueue(repoRoot, queue);
         return { items: candidates, prompt };
     }
-    async function ensureTranslatorSession(repoRoot, taskSlug, targetLanguage) {
+    async function ensureTranslatorSession(repoRoot, targetLanguage) {
         void targetLanguage;
         if (!deps.sessionService) {
             throw new VcmError({
@@ -264,17 +264,7 @@ export function createCodexTranslationService(deps) {
                 statusCode: 500
             });
         }
-        const existing = await deps.sessionService.getRoleSession(repoRoot, taskSlug, CODEX_TRANSLATOR_ROLE);
-        if (existing?.status === "running") {
-            return existing;
-        }
-        if (existing?.claudeSessionId) {
-            return deps.sessionService.resumeRoleSession(repoRoot, taskSlug, CODEX_TRANSLATOR_ROLE, {
-                model: existing.model,
-                effort: existing.effort
-            });
-        }
-        return deps.sessionService.startRoleSession(repoRoot, taskSlug, CODEX_TRANSLATOR_ROLE, {
+        return deps.sessionService.ensureProjectTranslatorSession(repoRoot, {
             model: "gpt-5.5",
             effort: "medium"
         });
@@ -902,9 +892,7 @@ export function createCodexTranslationService(deps) {
             const activeExisting = (await loadRuntimeFileJobs(repoRoot)).find((job) => fileTranslationReplacementKey(job) === replacementKey &&
                 isActiveFileTranslationJobStatus(job.status));
             if (activeExisting) {
-                if (input.taskSlug) {
-                    void dispatchNext(repoRoot, input.taskSlug);
-                }
+                void dispatchNext(repoRoot);
                 return activeExisting;
             }
             const timestamp = now();
@@ -1003,9 +991,7 @@ export function createCodexTranslationService(deps) {
                 lastUpdatedAt: timestamp
             });
             await deps.fs.writeText(resolveRepoPath(repoRoot, job.reportPath), `# Translation Report\n\nStatus: queued\nJob: ${jobId}\n`);
-            if (input.taskSlug) {
-                void dispatchNext(repoRoot, input.taskSlug);
-            }
+            void dispatchNext(repoRoot);
             return job;
         },
         async createBootstrapRun(repoRoot, input) {
@@ -1062,9 +1048,7 @@ export function createCodexTranslationService(deps) {
             index.runs = [run, ...index.runs];
             index.updatedAt = timestamp;
             await saveBootstrapIndex(repoRoot, index);
-            if (input.taskSlug) {
-                void dispatchNext(repoRoot, input.taskSlug);
-            }
+            void dispatchNext(repoRoot);
             return run;
         },
         async createMemoryUpdate(repoRoot, input) {
@@ -1120,9 +1104,7 @@ export function createCodexTranslationService(deps) {
                     "Delete or merge stale, duplicate, temporary, and task-local content."
                 ]
             });
-            if (input.taskSlug) {
-                void dispatchNext(repoRoot, input.taskSlug);
-            }
+            void dispatchNext(repoRoot);
             return queueItem;
         },
         async readFileJobOutput(repoRoot, jobId) {
@@ -1156,14 +1138,12 @@ export function createCodexTranslationService(deps) {
                 });
             }
             const timestamp = now();
-            const jobId = `conversation-${safeId(input.role)}-${Date.now()}-${createId().slice(0, 8)}`;
-            const jobRoot = `${CONVERSATION_RUNTIME_DIR}/${safeId(input.taskSlug)}/${safeId(input.role)}/jobs/${jobId}`;
+            const jobId = `conversation-${Date.now()}-${createId().slice(0, 8)}`;
+            const jobRoot = `${CONVERSATION_RUNTIME_DIR}/jobs/${jobId}`;
             const sourceHash = `sha256:${sha256(sourceText)}`;
             const targetLanguage = input.targetLanguage.trim() || "zh-CN";
             const job = {
                 id: jobId,
-                taskSlug: input.taskSlug,
-                role: input.role,
                 direction: input.direction,
                 sourceHash,
                 sourceLanguage: input.sourceLanguage.trim() || "auto",
@@ -1187,15 +1167,10 @@ export function createCodexTranslationService(deps) {
                 version: 1,
                 baseRepoRoot: repoRoot,
                 pathBase: "baseRepoRoot",
-                job,
-                taskSlug: input.taskSlug,
-                role: input.role,
                 direction: input.direction,
-                sourceHash,
                 sourceLanguage: job.sourceLanguage,
                 targetLanguage,
                 translationProfile: input.translationProfile?.trim() || DEFAULT_PROFILE,
-                contextText: input.contextText,
                 sourceContentBoundary: "VCM_TEXT",
                 sourceText,
                 absolutePaths: {
@@ -1208,8 +1183,8 @@ export function createCodexTranslationService(deps) {
                     format: "plain-text"
                 }
             });
-            if (input.taskSlug && !input.deferDispatch) {
-                void dispatchNext(repoRoot, input.taskSlug);
+            if (!input.deferDispatch) {
+                void dispatchNext(repoRoot);
             }
             return job;
         },
@@ -1290,6 +1265,7 @@ export function createCodexTranslationService(deps) {
             return job;
         },
         async handleCodexHook(repoRoot, eventName, taskSlug) {
+            void taskSlug;
             if (eventName === "UserPromptSubmit") {
                 const queue = await loadQueue(repoRoot);
                 const active = queue.activeItemId
@@ -1306,10 +1282,11 @@ export function createCodexTranslationService(deps) {
             }
             if (eventName === "Stop") {
                 await validateActiveQueueItem(repoRoot);
-                if (taskSlug) {
-                    await dispatchNext(repoRoot, taskSlug);
-                }
+                await dispatchNext(repoRoot);
             }
+        },
+        ensureTranslatorSession(repoRoot) {
+            return ensureTranslatorSession(repoRoot, "zh-CN");
         }
     };
 }