vibe-coding-master 0.3.22 → 0.3.23

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/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/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,

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");
         }
     };
 }

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

@@ -12,8 +12,9 @@ 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/runtime/session.json";
+const CODEX_TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
 const CODEX_TRANSLATOR_CONFIG_PATH = ".ai/codex-translator/config.toml";
+const PROJECT_TRANSLATOR_SCOPE = "__project__";
 export function createSessionService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
@@ -104,14 +105,167 @@ export function createSessionService(deps) {
         await persistRoleSessionRecord(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, record);
         return record;
     }
+    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 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.",
+                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);
+        const runtimeSession = await deps.runtime.createSession({
+            taskSlug: PROJECT_TRANSLATOR_SCOPE,
+            role: CODEX_TRANSLATOR_ROLE,
+            command: startCommand.command,
+            args: startCommand.args,
+            cwd: startCommand.cwd,
+            env: {
+                VCM_API_URL: deps.apiUrl,
+                VCM_TASK_REPO_ROOT: repoRoot,
+                VCM_TASK_SLUG: PROJECT_TRANSLATOR_SCOPE,
+                VCM_ROLE: CODEX_TRANSLATOR_ROLE,
+                VCM_SESSION_ID: claudeSessionId
+            },
+            cols: input.cols,
+            rows: input.rows
+        });
+        const timestamp = now();
+        const record = {
+            id: runtimeSession.id,
+            claudeSessionId,
+            taskSlug: PROJECT_TRANSLATOR_SCOPE,
+            role: CODEX_TRANSLATOR_ROLE,
+            status: runtimeSession.status,
+            activityStatus: "idle",
+            command: startCommand.display,
+            permissionMode: "default",
+            model,
+            effort,
+            cwd: startCommand.cwd,
+            terminalBackend: "node-pty",
+            pid: runtimeSession.pid,
+            startedAt: runtimeSession.startedAt,
+            updatedAt: timestamp,
+            lastOutputAt: runtimeSession.lastOutputAt,
+            exitCode: runtimeSession.exitCode
+        };
+        deps.registry.upsert(record);
+        await persistCodexTranslatorSession(deps.fs, repoRoot, record);
+        return record;
+    }
     return {
+        startProjectTranslatorSession(repoRoot, input = {}) {
+            return launchProjectTranslatorSession(repoRoot, input, "fresh");
+        },
+        resumeProjectTranslatorSession(repoRoot, input = {}) {
+            return launchProjectTranslatorSession(repoRoot, input, "resume");
+        },
+        async stopProjectTranslatorSession(repoRoot) {
+            const existing = await this.getProjectTranslatorSession(repoRoot);
+            if (!existing) {
+                throw new VcmError({
+                    code: "SESSION_MISSING",
+                    message: "Codex Translator session has not been started.",
+                    statusCode: 404
+                });
+            }
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            const updated = {
+                ...existing,
+                status: "exited",
+                activityStatus: "idle",
+                updatedAt: now()
+            };
+            deps.registry.upsert(updated);
+            await persistCodexTranslatorSession(deps.fs, repoRoot, updated);
+            return updated;
+        },
+        async restartProjectTranslatorSession(repoRoot, input = {}) {
+            const existing = await this.getProjectTranslatorSession(repoRoot);
+            if (!existing) {
+                return launchProjectTranslatorSession(repoRoot, input, "fresh");
+            }
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            deps.registry.remove(existing.id);
+            return launchProjectTranslatorSession(repoRoot, input, "fresh");
+        },
+        async getProjectTranslatorSession(repoRoot) {
+            const record = getRegisteredProjectTranslatorSession(deps.registry, deps.runtime)
+                ?? await loadPersistedCodexTranslatorSession(deps.fs, repoRoot);
+            return toRoleSessionRecordView(record, deps.runtime);
+        },
+        async ensureProjectTranslatorSession(repoRoot, input = {}) {
+            const existing = await this.getProjectTranslatorSession(repoRoot);
+            if (existing?.status === "running") {
+                return existing;
+            }
+            if (existing?.claudeSessionId) {
+                return this.resumeProjectTranslatorSession(repoRoot, {
+                    model: input.model ?? existing.model,
+                    effort: input.effort ?? existing.effort,
+                    cols: input.cols,
+                    rows: input.rows
+                });
+            }
+            return this.startProjectTranslatorSession(repoRoot, input);
+        },
+        async recordProjectTranslatorHookEvent(repoRoot, input) {
+            const current = await this.getProjectTranslatorSession(repoRoot);
+            if (!current) {
+                return undefined;
+            }
+            const timestamp = now();
+            const isStop = input.eventName === "Stop";
+            const updated = {
+                ...current,
+                claudeSessionId: input.sessionId ?? current.claudeSessionId,
+                transcriptPath: input.transcriptPath ?? current.transcriptPath,
+                cwd: input.cwd ?? current.cwd,
+                activityStatus: isStop ? "idle" : "running",
+                lastHookEventAt: timestamp,
+                lastTurnEndedAt: isStop ? timestamp : current.lastTurnEndedAt,
+                lastTurnStartedAt: isStop ? current.lastTurnStartedAt : timestamp,
+                updatedAt: timestamp
+            };
+            deps.registry.upsert(updated);
+            await persistCodexTranslatorSession(deps.fs, repoRoot, updated);
+            return updated;
+        },
         startRoleSession(repoRoot, taskSlug, role, input = {}) {
+            if (role === CODEX_TRANSLATOR_ROLE) {
+                void taskSlug;
+                return this.startProjectTranslatorSession(repoRoot, input);
+            }
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
         resumeRoleSession(repoRoot, taskSlug, role, input = {}) {
+            if (role === CODEX_TRANSLATOR_ROLE) {
+                void taskSlug;
+                return this.resumeProjectTranslatorSession(repoRoot, input);
+            }
             return launchRoleSession(repoRoot, taskSlug, role, input, "resume");
         },
         async stopRoleSession(repoRoot, taskSlug, role) {
+            if (role === CODEX_TRANSLATOR_ROLE) {
+                void taskSlug;
+                return this.stopProjectTranslatorSession(repoRoot);
+            }
             const existing = await this.getRoleSession(repoRoot, taskSlug, role);
             if (!existing) {
                 throw new VcmError({
@@ -136,6 +290,10 @@ export function createSessionService(deps) {
             return updated;
         },
         async restartRoleSession(repoRoot, taskSlug, role, input = {}) {
+            if (role === CODEX_TRANSLATOR_ROLE) {
+                void taskSlug;
+                return this.restartProjectTranslatorSession(repoRoot, input);
+            }
             const existing = await this.getRoleSession(repoRoot, taskSlug, role);
             if (!existing) {
                 return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
@@ -147,6 +305,10 @@ export function createSessionService(deps) {
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
         async getRoleSession(repoRoot, taskSlug, role) {
+            if (role === CODEX_TRANSLATOR_ROLE) {
+                void taskSlug;
+                return this.getProjectTranslatorSession(repoRoot);
+            }
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
@@ -163,12 +325,9 @@ 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 ROLE_NAMES) {
-                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);
+            for (const role of ROLE_NAMES.filter((candidate) => candidate !== CODEX_TRANSLATOR_ROLE)) {
+                const record = deps.registry.getByRole(taskSlug, role)
+                    ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record);
                 const session = toRoleSessionRecordView(record, deps.runtime);
                 if (session) {
                     sessions.push(session);
@@ -177,6 +336,15 @@ export function createSessionService(deps) {
             return sessions;
         },
         async recordRoleHookEvent(repoRoot, input) {
+            if (input.role === CODEX_TRANSLATOR_ROLE) {
+                void input.taskSlug;
+                return this.recordProjectTranslatorHookEvent(repoRoot, {
+                    eventName: input.eventName,
+                    sessionId: input.sessionId,
+                    transcriptPath: input.transcriptPath,
+                    cwd: input.cwd
+                });
+            }
             const current = await this.getRoleSession(repoRoot, input.taskSlug, input.role);
             if (!current || (!input.allowSessionMismatch && !matchesRoleHookSession(current, input))) {
                 return undefined;
@@ -385,6 +553,11 @@ function getRegisteredRoleSession(registry, runtime, taskSlug, role) {
         ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
     return scopeProjectRoleSession(scoped, taskSlug);
 }
+function getRegisteredProjectTranslatorSession(registry, runtime) {
+    const candidates = registry.list().filter((session) => session.role === CODEX_TRANSLATOR_ROLE);
+    const live = candidates.find((session) => runtime.getSession(session.id)?.status === "running");
+    return live ?? candidates.sort(compareSessionUpdatedAtDesc)[0];
+}
 function compareSessionUpdatedAtDesc(left, right) {
     return (right.updatedAt ?? "").localeCompare(left.updatedAt ?? "");
 }
@@ -399,11 +572,12 @@ function scopeProjectRoleSession(record, taskSlug) {
 }
 async function loadPersistedRoleRecordForRole(fs, baseRepoRoot, taskRepoRoot, stateRoot, taskSlug, role) {
     if (role === CODEX_TRANSLATOR_ROLE) {
-        return loadPersistedCodexTranslatorSession(fs, baseRepoRoot, taskSlug);
+        void taskSlug;
+        return loadPersistedCodexTranslatorSession(fs, baseRepoRoot);
     }
     return loadPersistedRoleRecord(fs, taskRepoRoot, stateRoot, taskSlug, role);
 }
-async function loadPersistedCodexTranslatorSession(fs, repoRoot, taskSlug) {
+async function loadPersistedCodexTranslatorSession(fs, repoRoot) {
     const sessionPath = resolveRepoPath(repoRoot, CODEX_TRANSLATOR_SESSION_PATH);
     if (!(await fs.pathExists(sessionPath))) {
         return undefined;
@@ -413,7 +587,10 @@ async function loadPersistedCodexTranslatorSession(fs, repoRoot, taskSlug) {
     if (!record) {
         return undefined;
     }
-    return scopeProjectRoleSession(record, taskSlug);
+    return {
+        ...record,
+        taskSlug: PROJECT_TRANSLATOR_SCOPE
+    };
 }
 async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role) {
     const current = await loadPersistedTaskSessionRecord(fs, repoRoot, stateRoot, taskSlug);
@@ -486,7 +663,7 @@ async function persistCodexTranslatorSession(fs, repoRoot, session) {
         updatedAt: session.updatedAt,
         record: {
             ...session,
-            taskSlug: session.taskSlug
+            taskSlug: PROJECT_TRANSLATOR_SCOPE
         }
     });
 }

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

@@ -157,6 +157,8 @@ export function createTranslationService(deps) {
     }
     function startTranscriptTail(roleSession) {
         const state = getState(roleSession.id);
+        state.taskSlug = roleSession.taskSlug;
+        state.role = roleSession.role;
         if (state.unsubscribeTranscript) {
             return;
         }
@@ -183,7 +185,7 @@ export function createTranslationService(deps) {
         const config = await loadConfig();
         let displayed = false;
         if (event.kind === "text") {
-            const shouldTranslate = config.outputMode === "all" || event.stopReason === "end_turn";
+            const shouldTranslate = shouldTranslateTextTranscriptEvent(state, event, config);
             displayed = shouldTranslate
                 ? processClaudeOutputText(sessionId, event.text, config, event.id, {
                     flushImmediately: event.stopReason === "end_turn"
@@ -206,6 +208,18 @@ export function createTranslationService(deps) {
             state.seenTranscriptIds.add(event.id);
         }
     }
+    function shouldTranslateTextTranscriptEvent(state, event, config) {
+        if (config.outputMode === "all") {
+            return true;
+        }
+        if (event.stopReason !== "end_turn") {
+            return false;
+        }
+        if (config.outputMode === "pm-final-only") {
+            return state.role === "project-manager";
+        }
+        return true;
+    }
     function processClaudeOutputText(sessionId, rawText, config, entryId, options = {}) {
         return startClaudeOutputTranslation(sessionId, rawText, config, {
             entryId,
@@ -890,8 +904,6 @@ export function createTranslationService(deps) {
             });
         }
         return deps.codexTranslationService.createConversationJob(input.repoRoot, {
-            taskSlug: input.taskSlug,
-            role: input.role,
             direction: input.direction,
             sourceText: input.text,
             sourceLanguage: input.sourceLanguage,
@@ -921,7 +933,6 @@ export function createTranslationService(deps) {
             }
             try {
                 return await deps.codexTranslationService.validateConversationResult(repoRoot, {
-                    taskSlug: job.taskSlug,
                     resultPath: job.resultPath,
                     sourceHash: job.sourceHash,
                     targetLanguage: job.targetLanguage

package/dist/backend/templates/handoff.js

@@ -15,9 +15,9 @@ Task-specific context and coder guidance go here, not in source-code comments.
 Source-code comments should only describe durable behavior, contracts, invariants,
 error boundaries, or non-obvious logic that should remain useful after this task.
 
-| File | Action | Task Context | Durable Code Comment Needed | Coder Work | Allowed Freedom | VCM:CODE | Proof Point | Replan Trigger |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD |
+| ID | File | Action | Task Context | Durable Code Comment Needed | Coder Work | Allowed Freedom | VCM:CODE | Proof Point | Replan Trigger |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| SCF-001 | TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD | TBD |
 
 ## Implementation Plan
 

package/dist/backend/templates/harness/architect-agent.js

@@ -27,7 +27,8 @@ export function renderArchitectHarnessRules() {
 
 - Define the expected implementation scope: affected modules, changed or created files, each file's responsibility, why it is in scope, and user-visible behavior changes.
 - Define every non-private callable surface intended for use outside its file: visibility, signature shape, responsibility, expected callers, behavior contract, side effects, and error boundaries.
-- Include a \`Scaffold Manifest\` for task-specific file context: file action, why the file is in scope, coder work, allowed implementation freedom, expected \`VCM:CODE\` placeholders, durable code comment needs, proof points, and Replan triggers.
+- Include a \`Scaffold Manifest\` for task-specific file context: stable row ID, file action, why the file is in scope, coder work, allowed implementation freedom, expected \`VCM:CODE\` placeholders, durable code comment needs, proof points, and Replan triggers.
+- Give each Scaffold Manifest row a stable ID such as \`SCF-001\`; use that ID in any related \`VCM:CODE\` marker so coder can report completion by ID.
 - Put task context, phase notes, handoff instructions, temporary rationale, and coder guidance in the \`Scaffold Manifest\`, not in source-code comments.
 - Cover architecture docs impact, known risks, and Replan triggers.
 - For docs impact, state whether changes belong in \`docs/ARCHITECTURE.md\`, affected \`<module>/ARCHITECTURE.md\`, \`.ai/generated/public-surface.json\`, or no durable architecture doc.
@@ -41,7 +42,7 @@ export function renderArchitectHarnessRules() {
 - Define every new or changed non-private callable surface directly in code with its signature shape and contract comment.
 - When changing an existing non-private callable surface, update its signature and contract comment in code before coder work starts; leave \`VCM:CODE\` only where implementation must change.
 - Non-private callable surface includes any function, method, type, trait, enum, constant, re-export, or similar symbol that another file can call or depend on.
-- Mark incomplete implementation bodies with \`VCM:CODE\`; coder must implement them and remove the markers before handoff.
+- Mark incomplete implementation bodies with \`VCM:CODE <Scaffold Manifest ID>\`; coder must implement them and remove the markers before handoff.
 - Architect scaffolding may include modules, files, signatures, type shapes, durable comments, and placeholder bodies, but not real business implementation beyond minimal scaffold code.
 - Coder may add private implementation helpers, but must not add or change cross-file callable surface without architect replan.
 

package/dist/backend/templates/harness/coder-agent.js

@@ -10,7 +10,7 @@ export function renderCoderHarnessRules() {
 ### Coder Implementation Discipline
 
 - Implement the architect-defined scaffold exactly; do not change file responsibilities, callable-surface signatures, or architect-defined contract intent unless the architecture plan explicitly allows it.
-- Implement every \`VCM:CODE\` placeholder and remove all \`VCM:CODE\` markers before handoff.
+- Implement every \`VCM:CODE\` placeholder, track completion by Scaffold Manifest ID when present, and remove all \`VCM:CODE\` markers before handoff.
 - Do not fake completion: no hardcoded success, disabled logic, swallowed errors, test-only shortcuts, or silent fallback that hides failure.
 - Keep the diff inside approved scope: no unrelated rewrites, drive-by refactors, renamed symbols, moved files, or formatting churn.
 - Preserve existing behavior unless the architecture plan explicitly changes it; keep existing call sites and shared code paths working.
@@ -40,6 +40,11 @@ export function renderCoderHarnessRules() {
 - Do not weaken, delete, or skip tests to make validation pass.
 - Record confirmed out-of-scope issues found during implementation in \`.ai/vcm/handoffs/known-issues.md\`.
 
+### Handoff
+
+- In the route message back to project-manager, include a \`Scaffold Completion\` section when the architecture plan contains a Scaffold Manifest.
+- The \`Scaffold Completion\` section must report completed Scaffold Manifest IDs or \`VCM:CODE\` IDs, remaining markers if any, private helpers added, manifest deviations, and whether Replan is needed.
+
 ### Generated Context
 
 - Regenerate \`.ai/generated/module-index.json\` with \`.ai/tools/generate-module-index\` after module, manifest, source-file, or test-file changes.