vibe-coding-master 0.6.2 → 0.6.4

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

@@ -52,6 +52,17 @@ export function registerTranslationRoutes(app, deps) {
             text: request.body?.text ?? ""
         });
     });
+    app.post("/api/tasks/:taskSlug/sessions/:role/translation/latest-reply", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseRole(request.params.role);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        return deps.translationService.translateLatestReply({
+            repoRoot: project.repoRoot,
+            taskRepoRoot: getTaskRuntimeRepoRoot(task),
+            taskSlug: request.params.taskSlug,
+            role
+        });
+    });
     app.post("/api/tasks/:taskSlug/sessions/:role/translation/send", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);

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

@@ -13,6 +13,8 @@ const POLL_LONG_BACKOFF_MS = 30_000;
 const MAX_FAILURES_BEFORE_LONG_BACKOFF = 3;
 const DEFAULT_POLL_TIMEOUT_MS = 35_000;
 const LARK_REGISTRATION_CONFIRM_TIMEOUT_MS = 15_000;
+const GATEWAY_ROUND_FINAL_WAIT_MS = 12_000;
+const GATEWAY_ROUND_FINAL_POLL_MS = 250;
 const GATEWAY_TRANSLATION_FAILURE_TEXT = "PM 回复已收到，但翻译失败。\n发送 /retry 重新翻译。";
 const COMMANDS_ALLOWED_WHEN_DISABLED = new Set([
     "help",
@@ -663,12 +665,15 @@ export function createGatewayService(deps) {
     }
     async function enableGatewayTranslationRuntime() {
         const preferences = await deps.appSettings.getPreferences();
-        if (preferences.translationEnabled && preferences.translationAutoSendEnabled) {
+        if (preferences.translationEnabled &&
+            preferences.translationAutoSendEnabled &&
+            preferences.translationOutputMode === "round-final") {
             return;
         }
         await deps.appSettings.updatePreferences({
             translationEnabled: true,
-            translationAutoSendEnabled: true
+            translationAutoSendEnabled: true,
+            translationOutputMode: "round-final"
         });
     }
     async function startGateway() {
@@ -1111,19 +1116,12 @@ export function createGatewayService(deps) {
                 return;
             }
             const events = await readTranscriptTextEvents(transcriptPath);
-            const latestReply = selectLatestTurnReply(events, input.session);
-            if (latestReply) {
-                await saveLatestPmReply(input, latestReply);
-            }
-            const settings = await deps.settings.loadSettings();
-            const account = toAccount(settings);
-            const boundUserId = settings.binding.boundUserId;
-            // A disarmed gateway never touches the channel: skip the outbound push.
-            // The latest reply was already cached above and replays on the next /start.
-            if (!connectionEnabled || !settings.enabled || !account || !boundUserId) {
+            const round = await waitForGatewayRoundFinal(input.repoRoot, input.taskSlug);
+            if (!round) {
                 return;
             }
             const cursorKey = `${input.taskSlug}:project-manager:${input.session.claudeSessionId}`;
+            const settings = await deps.settings.loadSettings();
             const cursor = settings.pushCursors[cursorKey];
             const nextEvents = selectEventsAfterCursor(events, cursor?.lastTranscriptEventId)
                 .filter(isFinalTurnTextEvent);
@@ -1134,7 +1132,18 @@ export function createGatewayService(deps) {
             if (!text) {
                 return;
             }
-            const roundNotice = await getGatewayRoundNotice(input.repoRoot, input.taskSlug);
+            const latestReply = selectLatestTurnReply(nextEvents, input.session);
+            if (latestReply) {
+                await saveLatestPmReply(input, latestReply);
+            }
+            const account = toAccount(settings);
+            const boundUserId = settings.binding.boundUserId;
+            // A disarmed gateway never touches the channel: skip the outbound push.
+            // The round-final PM reply was already cached above and replays on the next /start.
+            if (!connectionEnabled || !settings.enabled || !account || !boundUserId) {
+                return;
+            }
+            const roundNotice = formatGatewayRoundNotice(round);
             const originalMessage = formatGatewayPmOriginalReply(text, roundNotice);
             await sendGatewayText(settings, boundUserId, originalMessage);
             let output;
@@ -1182,6 +1191,40 @@ export function createGatewayService(deps) {
                 error: output?.translationError
             });
         },
+        async handleRoleStopFailure(input) {
+            const round = await getGatewayRoundState(input.repoRoot, input.taskSlug);
+            if (round?.stopReason === "manual-interrupt") {
+                return;
+            }
+            const settings = await deps.settings.loadSettings();
+            const account = toAccount(settings);
+            const boundUserId = settings.binding.boundUserId;
+            if (!connectionEnabled || !settings.enabled || !account || !boundUserId) {
+                return;
+            }
+            const message = formatGatewayRoleStopFailure(input, round);
+            await sendGatewayText(settings, boundUserId, message);
+            const current = await deps.settings.loadSettings();
+            await deps.settings.saveSettings({
+                ...current,
+                lastMessageStatus: {
+                    checkedAt: now(),
+                    direction: "outbound",
+                    result: "error",
+                    command: "role-stop-failure",
+                    preview: message.slice(0, 160),
+                    error: input.error
+                },
+                updatedAt: now()
+            });
+            await deps.audit.record({
+                type: "gateway.role_stop_failure",
+                result: "error",
+                command: "role-stop-failure",
+                preview: message,
+                error: input.error
+            });
+        },
         getDiagnostics() {
             return {
                 polling: isRunning()
@@ -1194,7 +1237,21 @@ export function createGatewayService(deps) {
         }
         return settings.latestPmReplies[latestPmReplyKey(settings.currentProjectId, settings.currentTaskSlug)];
     }
-    async function getGatewayRoundNotice(repoRoot, taskSlug) {
+    async function waitForGatewayRoundFinal(repoRoot, taskSlug) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt <= GATEWAY_ROUND_FINAL_WAIT_MS) {
+            const round = await getGatewayRoundState(repoRoot, taskSlug);
+            if (round && isGatewayRoundFinal(round)) {
+                return round;
+            }
+            if (round && isGatewayNonFinalTerminalRound(round)) {
+                return undefined;
+            }
+            await delay(GATEWAY_ROUND_FINAL_POLL_MS);
+        }
+        return undefined;
+    }
+    async function getGatewayRoundState(repoRoot, taskSlug) {
         try {
             const [projectConfig, task] = await Promise.all([
                 deps.projectService.loadConfig(repoRoot),
@@ -1206,12 +1263,24 @@ export function createGatewayService(deps) {
                 stateRoot: projectConfig.stateRoot,
                 taskSlug
             });
-            return formatGatewayRoundNotice(round);
+            return round;
         }
         catch {
             return undefined;
         }
     }
+    function isGatewayRoundFinal(round) {
+        return round.status === "stopped"
+            && Boolean(round.roundId)
+            && !round.stopReason
+            && round.roleRecovery?.status !== "failed"
+            && round.flowPause?.reason !== "role-recovery-failed";
+    }
+    function isGatewayNonFinalTerminalRound(round) {
+        return round.status === "stopped" && (Boolean(round.stopReason) ||
+            round.roleRecovery?.status === "failed" ||
+            round.flowPause?.reason === "role-recovery-failed");
+    }
     function formatGatewayRoundNotice(round) {
         const roundLabel = round.roundSequence ? `第 ${round.roundSequence} 轮` : "当前 round";
         if (round.status === "stopped") {
@@ -1220,6 +1289,27 @@ export function createGatewayService(deps) {
         const activeRole = round.activeRole ? `，当前角色：${round.activeRole}` : "";
         return `${roundLabel}运行中${activeRole}。`;
     }
+    function formatGatewayRoleStopFailure(input, round) {
+        const roundLabel = round?.roundSequence ? `第 ${round.roundSequence} 轮` : "当前 round";
+        const retryLine = input.maxAttempts !== undefined
+            ? `Retry: ${input.attempt ?? 0}/${input.maxAttempts}`
+            : undefined;
+        return [
+            "VCM 角色异常中断，流程已暂停。",
+            `Task: ${input.taskSlug}`,
+            `Role: ${input.role}`,
+            `Round: ${roundLabel}`,
+            input.error ? `Reason: ${input.error}` : undefined,
+            retryLine,
+            input.errorDetails ? `Details: ${truncateGatewayFailureDetails(input.errorDetails)}` : undefined,
+            "",
+            "请在 VCM 中检查状态，或修复问题后继续给出下一步指令。"
+        ].filter((line) => line !== undefined).join("\n");
+    }
+    function truncateGatewayFailureDetails(value) {
+        const trimmed = value.trim();
+        return trimmed.length > 600 ? `${trimmed.slice(0, 600)}...` : trimmed;
+    }
     function formatGatewayPmOriginalReply(text, roundNotice) {
         return [
             "PM final reply 原文：",
@@ -1442,6 +1532,9 @@ function sleep(ms, signal) {
         }, { once: true });
     });
 }
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function normalizeBaseUrl(input, fallback) {
     const trimmed = input.trim();
     if (!trimmed) {

package/dist/backend/server.js

@@ -277,6 +277,7 @@ export function createDefaultServerDeps(options = {}) {
         translationWorkerService,
         fs,
         projectService,
+        roundService,
         appSettings
     });
     const gatewayChannels = createGatewayChannelRegistry([

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

@@ -241,15 +241,27 @@ export function createClaudeHookService(deps) {
         }
         const failure = parseStopFailureDiagnostic(input.event);
         if (!failure.retryable) {
+            if (await isManualInterruptedStopFailure(context, input.role)) {
+                return recordTurnEnd(input, context, eventName, {
+                    dispatchRouteFiles: false,
+                    notifyGateway: false,
+                    settleGuard: false
+                });
+            }
             await markStopFailureRecoveryFailed(input, context, failure, 0);
             return recordTurnEnd(input, context, eventName, {
                 dispatchRouteFiles: false,
                 notifyGateway: false,
-                settleGuard: false
+                settleGuard: false,
+                gatewayStopFailure: {
+                    ...failure,
+                    attempt: 0,
+                    maxAttempts: MAX_ROLE_RETRY_ATTEMPTS
+                }
             });
         }
-        const retryScheduled = await scheduleStopFailureRetry(input, context, failure);
-        if (retryScheduled) {
+        const retryResult = await scheduleStopFailureRetry(input, context, failure);
+        if (retryResult === "scheduled") {
             return {
                 ok: true,
                 eventName,
@@ -262,7 +274,8 @@ export function createClaudeHookService(deps) {
         return recordTurnEnd(input, context, eventName, {
             dispatchRouteFiles: false,
             notifyGateway: false,
-            settleGuard: false
+            settleGuard: false,
+            ...(retryResult === "manual-interrupt" ? {} : { gatewayStopFailure: failure })
         });
     }
     async function processPostCompactHook(input) {
@@ -344,6 +357,17 @@ export function createClaudeHookService(deps) {
                 session
             }).catch(() => undefined);
         }
+        if (boundToTask && options.gatewayStopFailure) {
+            void deps.gatewayService?.handleRoleStopFailure({
+                repoRoot: context.project.repoRoot,
+                taskSlug: context.taskSlug,
+                role: input.role,
+                error: options.gatewayStopFailure.error,
+                errorDetails: options.gatewayStopFailure.errorDetails,
+                attempt: options.gatewayStopFailure.attempt,
+                maxAttempts: options.gatewayStopFailure.maxAttempts
+            }).catch(() => undefined);
+        }
         const dispatched = options.dispatchRouteFiles
             ? await deps.messageService.scanAndDispatchPendingRouteFiles(scopedRouteDispatchInput)
             : [];
@@ -370,14 +394,14 @@ export function createClaudeHookService(deps) {
     async function scheduleStopFailureRetry(input, context, failure) {
         const preferences = await deps.appSettings.getPreferences();
         if (!preferences.roleRetryEnabled || !deps.runtime) {
-            return false;
+            return "not-scheduled";
         }
         const stateInput = createRoundStateInput(context);
         const currentRoundState = await deps.roundService.getSessionRoundState(stateInput);
         if (currentRoundState.stopReason === "manual-interrupt"
             && currentRoundState.status === "stopped"
             && currentRoundState.activeRole === input.role) {
-            return false;
+            return "manual-interrupt";
         }
         const previousAttempt = currentRoundState.roleRecovery?.role === input.role &&
             currentRoundState.roleRecovery.status !== "failed"
@@ -388,7 +412,7 @@ export function createClaudeHookService(deps) {
         if (attempt > MAX_ROLE_RETRY_ATTEMPTS) {
             clearStopFailureRetryTimer(context.project.repoRoot, context.taskSlug, input.role);
             await markStopFailureRecoveryFailed(input, context, failure, MAX_ROLE_RETRY_ATTEMPTS, timestamp);
-            return false;
+            return "not-scheduled";
         }
         const nextRetryAt = new Date(Date.parse(timestamp) + attempt * ROLE_RETRY_BASE_DELAY_MS).toISOString();
         await deps.roundService.setRoleRecovery({
@@ -408,7 +432,18 @@ export function createClaudeHookService(deps) {
         });
         await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
         scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt);
-        return true;
+        return "scheduled";
+    }
+    async function isManualInterruptedStopFailure(context, role) {
+        try {
+            const state = await deps.roundService.getSessionRoundState(createRoundStateInput(context));
+            return state.status === "stopped" &&
+                state.stopReason === "manual-interrupt" &&
+                state.activeRole === role;
+        }
+        catch {
+            return false;
+        }
     }
     function scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt) {
         const key = stopFailureRecoveryKey(context.project.repoRoot, context.taskSlug, input.role);
@@ -441,7 +476,15 @@ export function createClaudeHookService(deps) {
             await recordTurnEnd(input, context, "StopFailure", {
                 dispatchRouteFiles: false,
                 notifyGateway: false,
-                settleGuard: false
+                settleGuard: false,
+                gatewayStopFailure: {
+                    error: recovery.error ?? "stop_failure",
+                    errorDetails: recovery.errorDetails,
+                    lastAssistantMessage: recovery.lastAssistantMessage,
+                    retryable: recovery.retryable ?? true,
+                    attempt: recovery.attempt,
+                    maxAttempts: recovery.maxAttempts
+                }
             });
             return;
         }

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

@@ -3,6 +3,7 @@ import { isVcmRoleName } from "../../shared/constants.js";
 import { TRANSLATION_ENTRY_RETENTION_LIMIT } from "../../shared/types/translation.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
+import { readLatestRoleTurnReply } from "./claude-transcript-reply.js";
 import { createTranslationQueueRegistry } from "./translation-queue.js";
 const TRANSLATION_SOURCE_LANGUAGE = "auto";
 const TRANSLATION_INPUT_MODE = "review-before-send";
@@ -243,11 +244,13 @@ export function createTranslationService(deps) {
         let displayed = false;
         if (event.kind === "text") {
             const shouldTranslate = shouldTranslateTextTranscriptEvent(state, event, config);
+            const metadata = getTextTranscriptEntryMetadata(event);
             displayed = shouldTranslate
                 ? processClaudeOutputText(sessionId, event.text, config, event.id, {
-                    flushImmediately: event.stopReason === "end_turn"
+                    flushImmediately: event.stopReason === "end_turn",
+                    metadata
                 })
-                : pushPreservedProseEntry(sessionId, event.id, event.text, config);
+                : pushPreservedProseEntry(sessionId, event.id, event.text, config, metadata);
             if (displayed && shouldTranslate) {
                 state.lastAssistantText = event.text;
             }
@@ -269,6 +272,9 @@ export function createTranslationService(deps) {
         if (config.outputMode === "all") {
             return true;
         }
+        if (config.outputMode === "round-final") {
+            return false;
+        }
         if (event.stopReason !== "end_turn") {
             return false;
         }
@@ -281,9 +287,16 @@ export function createTranslationService(deps) {
         return startClaudeOutputTranslation(sessionId, rawText, config, {
             entryId,
             replaceExisting: false,
-            flushImmediately: options.flushImmediately === true
+            flushImmediately: options.flushImmediately === true,
+            metadata: options.metadata
         }) !== undefined;
     }
+    function getTextTranscriptEntryMetadata(event) {
+        return {
+            ...(event.stopReason !== undefined ? { transcriptStopReason: event.stopReason } : {}),
+            transcriptTimestamp: event.timestamp
+        };
+    }
     function startClaudeOutputTranslation(sessionId, rawText, config, options) {
         const session = deps.runtime.getSession(sessionId);
         const roleSession = deps.sessionRegistry.get(sessionId);
@@ -304,7 +317,8 @@ export function createTranslationService(deps) {
                 config,
                 status: "queued",
                 contextUsed: false,
-                id: options.entryId
+                id: options.entryId,
+                ...options.metadata
             })
         };
         if (options.replaceExisting) {
@@ -439,10 +453,10 @@ export function createTranslationService(deps) {
     function pushPreservedTranscriptEntry(sessionId, entryId, sourceText, config) {
         return pushPreservedOutputEntry(sessionId, entryId, sourceText, "tool-output", config);
     }
-    function pushPreservedProseEntry(sessionId, entryId, sourceText, config) {
-        return pushPreservedOutputEntry(sessionId, entryId, sourceText, "prose", config);
+    function pushPreservedProseEntry(sessionId, entryId, sourceText, config, metadata = {}) {
+        return pushPreservedOutputEntry(sessionId, entryId, sourceText, "prose", config, metadata);
     }
-    function pushPreservedOutputEntry(sessionId, entryId, sourceText, sourceKind, config) {
+    function pushPreservedOutputEntry(sessionId, entryId, sourceText, sourceKind, config, metadata = {}) {
         if (!sourceText.trim()) {
             return false;
         }
@@ -462,7 +476,8 @@ export function createTranslationService(deps) {
             contextUsed: false,
             id: entryId,
             translatedText: sourceText,
-            completedAt: now()
+            completedAt: now(),
+            ...metadata
         });
         pushEntry(sessionId, entry);
         return true;
@@ -552,7 +567,11 @@ export function createTranslationService(deps) {
         markFailureRetrying(sessionId, existingFailure);
         const retrying = startClaudeOutputTranslation(sessionId, original.sourceText, config, {
             entryId: original.id,
-            replaceExisting: true
+            replaceExisting: true,
+            metadata: {
+                transcriptStopReason: original.transcriptStopReason,
+                transcriptTimestamp: original.transcriptTimestamp
+            }
         });
         if (!retrying) {
             throw new VcmError({
@@ -576,6 +595,8 @@ export function createTranslationService(deps) {
             translatedText: input.translatedText ?? "",
             status: input.status,
             contextUsed: input.contextUsed,
+            transcriptStopReason: input.transcriptStopReason,
+            transcriptTimestamp: input.transcriptTimestamp,
             boundaryKind: input.boundaryKind,
             conversationTurn: input.conversationTurn,
             occurredAt: input.occurredAt,
@@ -676,6 +697,7 @@ export function createTranslationService(deps) {
             };
         },
         async pollTaskFeed(input) {
+            const config = await loadConfig();
             const cursor = Number.isFinite(input.after) ? Math.max(1, Math.floor(input.after)) : 1;
             const maxEvents = Math.min(Math.max(1, Math.floor(input.limit ?? 500)), 1000);
             const roleSessions = await deps.sessionService.listRoleSessions(input.repoRoot, input.taskSlug);
@@ -700,6 +722,9 @@ export function createTranslationService(deps) {
                     status: state.status
                 });
             }
+            if (config.outputMode === "round-final") {
+                await translateRoundFinalReplyIfReady(input, config);
+            }
             const feed = getTaskFeed(input.taskRepoRoot, input.taskSlug);
             const events = feed.events
                 .filter((event) => event.seq >= cursor)
@@ -882,6 +907,51 @@ export function createTranslationService(deps) {
             }
             return entry;
         },
+        async translateLatestReply(input) {
+            const config = await loadConfig();
+            const roleSession = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role);
+            if (!roleSession || roleSession.status !== "running") {
+                throw new VcmError({
+                    code: "SESSION_NOT_RUNNING",
+                    message: `${input.role} session is not running.`,
+                    statusCode: 409
+                });
+            }
+            const reply = await readLatestRoleTurnReply(roleSession);
+            if (!reply?.text.trim()) {
+                throw new VcmError({
+                    code: "TRANSLATION_REPLY_NOT_FOUND",
+                    message: `No completed final reply was found for ${input.role}.`,
+                    statusCode: 404,
+                    hint: "Wait until the role finishes a Claude Code turn, then try again."
+                });
+            }
+            await prepareCache({
+                repoRoot: input.taskRepoRoot ?? input.repoRoot,
+                baseRepoRoot: input.repoRoot,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                sessionId: roleSession.id
+            });
+            startTranscriptTail(roleSession);
+            const entry = startClaudeOutputTranslation(roleSession.id, reply.text, config, {
+                replaceExisting: false,
+                flushImmediately: true,
+                metadata: {
+                    transcriptStopReason: "end_turn",
+                    ...(reply.transcriptTimestamp ? { transcriptTimestamp: reply.transcriptTimestamp } : {})
+                }
+            });
+            if (!entry) {
+                throw new VcmError({
+                    code: "TRANSLATION_NOT_STARTED",
+                    message: "Latest reply translation could not be queued.",
+                    statusCode: 409,
+                    hint: "Check that the role session is still running and try again."
+                });
+            }
+            return entry;
+        },
         async sendTranslatedInput(input) {
             await writeToCurrentRole(input.repoRoot, input.taskSlug, input.role, input.englishText);
         },
@@ -1039,6 +1109,86 @@ export function createTranslationService(deps) {
             };
         }
     };
+    async function translateRoundFinalReplyIfReady(input, config) {
+        if (!deps.roundService || !deps.projectService) {
+            return;
+        }
+        const projectConfig = await deps.projectService.loadConfig(input.repoRoot);
+        const round = await deps.roundService.getSessionRoundState({
+            repoRoot: input.repoRoot,
+            stateRepoRoot: input.taskRepoRoot,
+            stateRoot: projectConfig.stateRoot,
+            taskSlug: input.taskSlug
+        });
+        if (!isNormalStoppedRound(round)) {
+            return;
+        }
+        const candidate = findRoundFinalReplyCandidate(input, round);
+        if (!candidate || candidate.entry.status !== "preserved") {
+            return;
+        }
+        startClaudeOutputTranslation(candidate.sessionId, candidate.entry.sourceText, config, {
+            entryId: candidate.entry.id,
+            replaceExisting: true,
+            flushImmediately: true,
+            metadata: {
+                transcriptStopReason: candidate.entry.transcriptStopReason,
+                transcriptTimestamp: candidate.entry.transcriptTimestamp
+            }
+        });
+    }
+    function isNormalStoppedRound(round) {
+        return round.status === "stopped"
+            && Boolean(round.roundId)
+            && !round.stopReason
+            && round.roleRecovery?.status !== "failed"
+            && round.flowPause?.reason !== "role-recovery-failed";
+    }
+    function findRoundFinalReplyCandidate(input, round) {
+        const candidates = [];
+        for (const [sessionId, state] of sessionStates) {
+            if (!isRoundFinalCandidateState(state, input, round.activeRole)) {
+                continue;
+            }
+            for (const entry of state.entries) {
+                if (isRoundFinalCandidateEntry(entry, input, round.stoppedAt)) {
+                    candidates.push({ sessionId, entry });
+                }
+            }
+        }
+        return candidates
+            .sort((left, right) => compareRoundFinalCandidates(left.entry, right.entry))
+            .at(-1);
+    }
+    function isRoundFinalCandidateState(state, input, activeRole) {
+        if (state.repoRoot !== input.taskRepoRoot || state.taskSlug !== input.taskSlug || !state.role) {
+            return false;
+        }
+        return !activeRole || state.role === activeRole;
+    }
+    function isRoundFinalCandidateEntry(entry, input, stoppedAt) {
+        if (entry.taskSlug !== input.taskSlug ||
+            entry.direction !== "cc-output-to-user" ||
+            entry.sourceKind !== "prose" ||
+            entry.transcriptStopReason !== "end_turn") {
+            return false;
+        }
+        if (entry.status !== "preserved" && entry.status !== "queued" && entry.status !== "translating" && entry.status !== "translated") {
+            return false;
+        }
+        if (!stoppedAt || !entry.transcriptTimestamp) {
+            return true;
+        }
+        return entry.transcriptTimestamp <= stoppedAt;
+    }
+    function compareRoundFinalCandidates(left, right) {
+        const leftTime = left.transcriptTimestamp ?? left.createdAt;
+        const rightTime = right.transcriptTimestamp ?? right.createdAt;
+        if (leftTime === rightTime) {
+            return left.id.localeCompare(right.id);
+        }
+        return leftTime.localeCompare(rightTime);
+    }
     async function findReusableGatewayOutputTranslation(input, config) {
         const graceDeadline = Date.now() + (input.sourceEntryIds?.length ? GATEWAY_TRANSLATION_REUSE_GRACE_MS : 0);
         while (true) {

package/dist/shared/types/app-settings.js

@@ -12,6 +12,7 @@ export const TRANSLATION_TARGET_LANGUAGE_OPTIONS = [
     { value: "es", label: "Spanish" }
 ];
 export const TRANSLATION_OUTPUT_MODE_OPTIONS = [
+    { value: "round-final", label: "Round final reply" },
     { value: "pm-final-only", label: "PM final reply" },
     { value: "final-only", label: "Each role final reply" },
     { value: "all", label: "All replies" }