vibe-coding-master 0.6.0 → 0.6.2

package/dist/backend/services/runtime-recovery-service.js

@@ -0,0 +1,322 @@
+import path from "node:path";
+import { GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const TRANSLATOR_SESSION_PATH = ".ai/vcm/translations/session.json";
+const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
+const BOOTSTRAP_SESSION_PATH = ".ai/vcm/bootstrap/session.json";
+const HARNESS_FEEDBACK_STATE_PATH = ".ai/vcm/harness-feedback/state.json";
+const RECOVERABLE_FEEDBACK_STATES = new Set(["analyzing", "applying"]);
+export function createRuntimeRecoveryService(deps) {
+    const now = deps.now ?? (() => new Date().toISOString());
+    return {
+        async recoverProject(repoRoot) {
+            const recoveredAt = now();
+            const context = {
+                changedPaths: new Set(),
+                warnings: []
+            };
+            await runStep(context, "cleanup translation runtime", () => deps.translationWorkerService?.cleanupStartupRuntime(repoRoot) ?? Promise.resolve());
+            const config = await deps.projectService.loadConfig(repoRoot);
+            await runStep(context, "recover project tool sessions", () => recoverProjectToolSessions(repoRoot, recoveredAt, context));
+            await runStep(context, "recover harness bootstrap", () => recoverHarnessBootstrap(repoRoot, recoveredAt, context));
+            await runStep(context, "recover harness feedback", () => recoverHarnessFeedback(repoRoot, recoveredAt, context));
+            const tasks = await deps.taskService.listTasks(repoRoot);
+            for (const task of tasks.filter((candidate) => candidate.cleanupStatus !== "cleaned")) {
+                const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+                await runStep(context, `recover task ${task.taskSlug}`, async () => {
+                    await recoverTaskSessions(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
+                    const roundRecovered = await recoverRound(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
+                    await recoverMessages(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
+                    await recoverGateReview(taskRepoRoot, recoveredAt, context);
+                    if ((roundRecovered || task.status === "running") && !hasLiveTaskSession(task.taskSlug)) {
+                        await deps.taskService.updateTaskStatus(repoRoot, task.taskSlug, "stopped");
+                    }
+                });
+            }
+            return {
+                repoRoot,
+                recoveredAt,
+                changedPaths: [...context.changedPaths].sort(),
+                warnings: context.warnings
+            };
+        }
+    };
+    async function recoverProjectToolSessions(repoRoot, timestamp, context) {
+        await recoverProjectRoleSessionFile(repoRoot, TRANSLATOR_SESSION_PATH, timestamp, context);
+        await recoverProjectRoleSessionFile(repoRoot, HARNESS_ENGINEER_SESSION_PATH, timestamp, context);
+    }
+    async function recoverProjectRoleSessionFile(repoRoot, relativePath, timestamp, context) {
+        const absolutePath = path.join(repoRoot, relativePath);
+        const state = await readJsonIfExists(absolutePath);
+        if (!state?.record) {
+            return;
+        }
+        const next = recoverRoleSessionRecord(state.record, timestamp);
+        if (!next.changed) {
+            return;
+        }
+        await deps.fs.writeJsonAtomic(absolutePath, {
+            ...state,
+            updatedAt: timestamp,
+            record: next.record
+        });
+        context.changedPaths.add(relativePath);
+    }
+    async function recoverTaskSessions(taskRepoRoot, stateRoot, taskSlug, timestamp, context) {
+        const relativePath = path.join(stateRoot, "sessions", `${taskSlug}.json`);
+        const absolutePath = path.join(taskRepoRoot, relativePath);
+        const state = await readJsonIfExists(absolutePath);
+        if (!state?.roles) {
+            return;
+        }
+        let changed = false;
+        const roles = {};
+        for (const [role, pointer] of Object.entries(state.roles)) {
+            if (!pointer) {
+                continue;
+            }
+            const record = pointer.record;
+            if (!record) {
+                roles[role] = pointer;
+                continue;
+            }
+            const next = recoverRoleSessionRecord(record, timestamp);
+            changed ||= next.changed;
+            roles[role] = {
+                ...pointer,
+                status: next.record.status,
+                record: next.record
+            };
+        }
+        if (!changed) {
+            return;
+        }
+        await deps.fs.writeJsonAtomic(absolutePath, {
+            ...state,
+            updatedAt: timestamp,
+            roles
+        });
+        context.changedPaths.add(relativePath);
+    }
+    function recoverRoleSessionRecord(record, timestamp) {
+        const live = record.id ? deps.runtime.getSession(record.id) : undefined;
+        if (live?.status === "running") {
+            return { changed: false, record };
+        }
+        const recoveredStatus = getRecoveredSessionStatus(record);
+        const shouldIdle = record.activityStatus !== "idle";
+        if (record.status === recoveredStatus && !shouldIdle) {
+            return { changed: false, record };
+        }
+        return {
+            changed: true,
+            record: {
+                ...record,
+                status: recoveredStatus,
+                activityStatus: "idle",
+                lastTurnEndedAt: record.lastTurnEndedAt ?? timestamp,
+                updatedAt: timestamp
+            }
+        };
+    }
+    async function recoverRound(taskRepoRoot, stateRoot, taskSlug, timestamp, context) {
+        const relativePath = path.join(stateRoot, "rounds", `${taskSlug}.json`);
+        const absolutePath = path.join(taskRepoRoot, relativePath);
+        const state = await readJsonIfExists(absolutePath);
+        if (!state) {
+            return false;
+        }
+        let changed = false;
+        let current = state.currentRound;
+        if (current?.status === "running" && !hasLiveRoundRole(taskSlug, current.activeRole)) {
+            const activeDurationMs = current.activeTurnStartedAt
+                ? getDurationMs(current.activeTurnStartedAt, timestamp)
+                : 0;
+            const completedIncrement = current.activeTurnStartedAt ? 1 : 0;
+            current = {
+                ...current,
+                status: "stopped",
+                lastTurnEndedAt: current.lastTurnEndedAt ?? timestamp,
+                stoppedAt: timestamp,
+                stopReason: "runtime-recovery",
+                settleDeadlineAt: undefined,
+                activeTurnStartedAt: undefined,
+                ccActiveMs: (current.ccActiveMs ?? 0) + activeDurationMs,
+                completedTurnCount: (current.completedTurnCount ?? 0) + completedIncrement
+            };
+            changed = true;
+            state.currentRound = current;
+            state.lastStoppedRound = current;
+            state.totalCompletedTurnCount = (state.totalCompletedTurnCount ?? 0) + completedIncrement;
+            state.totalCcActiveMs = (state.totalCcActiveMs ?? 0) + activeDurationMs;
+            state.pendingUserReply = undefined;
+        }
+        if (state.roleRecovery?.status === "waiting" || state.roleRecovery?.status === "retrying") {
+            state.roleRecovery = undefined;
+            changed = true;
+        }
+        if (!changed) {
+            return false;
+        }
+        state.updatedAt = timestamp;
+        await deps.fs.writeJsonAtomic(absolutePath, state);
+        context.changedPaths.add(relativePath);
+        return true;
+    }
+    async function recoverMessages(taskRepoRoot, stateRoot, taskSlug, timestamp, context) {
+        const relativePath = path.join(stateRoot, "messages", `${taskSlug}.jsonl`);
+        const absolutePath = path.join(taskRepoRoot, relativePath);
+        if (!(await deps.fs.pathExists(absolutePath))) {
+            return;
+        }
+        const lines = (await deps.fs.readText(absolutePath)).split(/\r?\n/).filter((line) => line.trim());
+        let changed = false;
+        const messages = lines.map((line) => {
+            const message = JSON.parse(line);
+            if (message.dispatchingAt && !message.acceptedAt) {
+                const next = {
+                    ...message,
+                    failureReason: "VCM restarted before this dispatch was confirmed. Resend the message if it is still needed."
+                };
+                delete next.dispatchingAt;
+                delete next.deliveredAt;
+                changed = true;
+                return next;
+            }
+            return message;
+        });
+        if (!changed) {
+            return;
+        }
+        const content = messages.length ? `${messages.map((message) => JSON.stringify(message)).join("\n")}\n` : "";
+        await deps.fs.writeText(absolutePath, content);
+        context.changedPaths.add(relativePath);
+        void timestamp;
+    }
+    async function recoverGateReview(taskRepoRoot, timestamp, context) {
+        const relativePath = path.join(".ai/vcm/gate-reviews", "index.json");
+        const absolutePath = path.join(taskRepoRoot, relativePath);
+        const index = await readJsonIfExists(absolutePath);
+        if (!index?.gates) {
+            return;
+        }
+        let changed = false;
+        const gates = { ...index.gates };
+        for (const gate of GATE_REVIEW_GATES) {
+            const record = gates[gate];
+            if (record?.status !== "running") {
+                continue;
+            }
+            gates[gate] = {
+                ...record,
+                status: "pending",
+                error: "VCM restarted before this Gate Review completed. Request the gate again if it is still required.",
+                updatedAt: timestamp
+            };
+            changed = true;
+        }
+        const activeGate = isGateReviewGate(index.activeGate) && gates[index.activeGate].status === "running"
+            ? index.activeGate
+            : null;
+        changed ||= index.activeGate !== activeGate;
+        if (!changed) {
+            return;
+        }
+        await deps.fs.writeJsonAtomic(absolutePath, {
+            ...index,
+            activeGate,
+            gates,
+            updatedAt: timestamp
+        });
+        context.changedPaths.add(relativePath);
+    }
+    async function recoverHarnessBootstrap(repoRoot, _timestamp, context) {
+        const absolutePath = path.join(repoRoot, BOOTSTRAP_SESSION_PATH);
+        const state = await readJsonIfExists(absolutePath);
+        if (state?.status !== "running") {
+            return;
+        }
+        await deps.fs.removePath?.(absolutePath, { force: true });
+        context.changedPaths.add(BOOTSTRAP_SESSION_PATH);
+    }
+    async function recoverHarnessFeedback(repoRoot, timestamp, context) {
+        const absolutePath = path.join(repoRoot, HARNESS_FEEDBACK_STATE_PATH);
+        const state = await readJsonIfExists(absolutePath);
+        if (!state?.status || !RECOVERABLE_FEEDBACK_STATES.has(state.status)) {
+            return;
+        }
+        const previousStatus = state.status;
+        const next = {
+            ...state,
+            status: "awaiting_user_approval",
+            updatedAt: timestamp,
+            active: state.active
+                ? {
+                    ...state.active,
+                    updatedAt: timestamp
+                }
+                : state.active
+        };
+        await deps.fs.writeJsonAtomic(absolutePath, next);
+        context.changedPaths.add(HARNESS_FEEDBACK_STATE_PATH);
+        const analysisPath = state.active?.analysisPath;
+        if (analysisPath) {
+            const notePath = path.join(repoRoot, analysisPath);
+            if (!(await deps.fs.pathExists(notePath))) {
+                await deps.fs.writeText(notePath, [
+                    "# Harness Feedback Recovery",
+                    "",
+                    `VCM restarted while this harness feedback item was ${previousStatus}.`,
+                    "Review the current repository diff and either comment, reject, cancel, or approve explicitly."
+                ].join("\n"));
+                context.changedPaths.add(analysisPath);
+            }
+        }
+    }
+    function hasLiveTaskSession(taskSlug) {
+        return deps.runtime.listSessions(taskSlug).some((session) => session.status === "running");
+    }
+    function hasLiveRoundRole(taskSlug, role) {
+        if (!role) {
+            return false;
+        }
+        return deps.runtime.getSessionByRole(taskSlug, role)?.status === "running";
+    }
+    async function readJsonIfExists(absolutePath) {
+        if (!(await deps.fs.pathExists(absolutePath))) {
+            return undefined;
+        }
+        return deps.fs.readJson(absolutePath);
+    }
+}
+function getRecoveredSessionStatus(record) {
+    if (record.status === "done") {
+        return "done";
+    }
+    if (record.claudeSessionId?.trim()) {
+        return "resumable";
+    }
+    if (record.status === "not_started") {
+        return "not_started";
+    }
+    return "missing";
+}
+function getDurationMs(start, end) {
+    const startMs = Date.parse(start);
+    const endMs = Date.parse(end);
+    if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) {
+        return 0;
+    }
+    return Math.max(0, endMs - startMs);
+}
+function isGateReviewGate(value) {
+    return typeof value === "string" && GATE_REVIEW_GATES.includes(value);
+}
+async function runStep(context, label, run) {
+    try {
+        await run();
+    }
+    catch (error) {
+        context.warnings.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

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

@@ -74,6 +74,7 @@ export function createSessionService(deps) {
             cwd: taskRepoRoot
         };
         const runtimeSession = await deps.runtime.createSession({
+            repoRoot,
             taskSlug,
             role,
             command: startCommand.command,
@@ -166,6 +167,7 @@ export function createSessionService(deps) {
             cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
+            repoRoot,
             taskSlug: PROJECT_TRANSLATOR_SCOPE,
             role: TRANSLATOR_ROLE,
             command: startCommand.command,
@@ -264,6 +266,7 @@ export function createSessionService(deps) {
             cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
+            repoRoot,
             taskSlug: PROJECT_HARNESS_ENGINEER_SCOPE,
             role: HARNESS_ENGINEER_ROLE,
             command: startCommand.command,
@@ -425,6 +428,7 @@ export function createSessionService(deps) {
             cwd: launchCwd
         };
         const runtimeSession = await deps.runtime.createSession({
+            repoRoot,
             taskSlug: normalizeProjectScopedRecordForPersistence(session).taskSlug,
             role: session.role,
             command: startCommand.command,
@@ -515,6 +519,54 @@ export function createSessionService(deps) {
         const task = await deps.taskService.loadTask(repoRoot, session.taskSlug);
         await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, session);
     }
+    async function getProjectToolSessionView(repoRoot, role) {
+        const record = role === TRANSLATOR_ROLE
+            ? getRegisteredProjectTranslatorSession(deps.registry, deps.runtime)
+                ?? await loadPersistedTranslatorSession(deps.fs, repoRoot)
+            : getRegisteredProjectHarnessEngineerSession(deps.registry, deps.runtime)
+                ?? await loadPersistedHarnessEngineerSession(deps.fs, repoRoot);
+        const view = toRoleSessionRecordView(record, deps.runtime);
+        return view ? withHarnessRevisionView(repoRoot, view) : undefined;
+    }
+    async function markProjectToolActivityIdle(repoRoot, current, persist) {
+        const timestamp = now();
+        const updated = {
+            ...current,
+            activityStatus: "idle",
+            lastTurnEndedAt: timestamp,
+            updatedAt: timestamp
+        };
+        deps.registry.upsert(updated);
+        await persist(deps.fs, repoRoot, updated);
+        return updated;
+    }
+    async function getTaskRoleSessionView(repoRoot, taskSlug, role) {
+        const config = await deps.projectService.loadConfig(repoRoot);
+        const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const record = getRegisteredRoleSession(deps.registry, deps.runtime, taskSlug, role)
+            ?? await loadPersistedRoleRecordForRole(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, taskSlug, role);
+        const view = toRoleSessionRecordView(record, deps.runtime);
+        return view ? withHarnessRevisionView(repoRoot, view) : undefined;
+    }
+    async function markTaskRoleActivityIdle(repoRoot, taskSlug, role) {
+        const current = await getTaskRoleSessionView(repoRoot, taskSlug, role);
+        if (!current) {
+            return undefined;
+        }
+        const timestamp = now();
+        const updated = {
+            ...current,
+            activityStatus: "idle",
+            lastTurnEndedAt: timestamp,
+            updatedAt: timestamp
+        };
+        deps.registry.upsert(updated);
+        const config = await deps.projectService.loadConfig(repoRoot);
+        const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+        await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
+        return updated;
+    }
     return {
         startProjectTranslatorSession(repoRoot, input = {}) {
             return launchProjectTranslatorSession(repoRoot, input, "fresh");
@@ -940,6 +992,28 @@ export function createSessionService(deps) {
                 cwd: input.cwd
             });
         },
+        async markTerminalSessionActivityIdle(repoRoot, sessionId) {
+            const runtimeSession = deps.runtime.getSession(sessionId);
+            const registered = deps.registry.get(sessionId);
+            const role = registered?.role ?? runtimeSession?.role;
+            const taskSlug = registered?.taskSlug ?? runtimeSession?.taskSlug;
+            if (!role || !taskSlug) {
+                return undefined;
+            }
+            if (role === TRANSLATOR_ROLE) {
+                const current = await getProjectToolSessionView(repoRoot, TRANSLATOR_ROLE);
+                return current?.id === sessionId
+                    ? markProjectToolActivityIdle(repoRoot, current, persistTranslatorSession)
+                    : undefined;
+            }
+            if (role === HARNESS_ENGINEER_ROLE) {
+                const current = await getProjectToolSessionView(repoRoot, HARNESS_ENGINEER_ROLE);
+                return current?.id === sessionId
+                    ? markProjectToolActivityIdle(repoRoot, current, persistHarnessEngineerSession)
+                    : undefined;
+            }
+            return markTaskRoleActivityIdle(repoRoot, taskSlug, role);
+        },
         async markRoleActivityRunning(repoRoot, taskSlug, role) {
             const current = await this.getRoleSession(repoRoot, taskSlug, role);
             if (!current) {
@@ -960,22 +1034,21 @@ export function createSessionService(deps) {
             return updated;
         },
         async markRoleActivityIdle(repoRoot, taskSlug, role) {
-            const current = await this.getRoleSession(repoRoot, taskSlug, role);
-            if (!current) {
-                return undefined;
+            if (role === TRANSLATOR_ROLE) {
+                void taskSlug;
+                const current = await getProjectToolSessionView(repoRoot, TRANSLATOR_ROLE);
+                return current
+                    ? markProjectToolActivityIdle(repoRoot, current, persistTranslatorSession)
+                    : undefined;
             }
-            const timestamp = now();
-            const updated = {
-                ...current,
-                activityStatus: "idle",
-                lastTurnEndedAt: timestamp,
-                updatedAt: timestamp
-            };
-            deps.registry.upsert(updated);
-            const config = await deps.projectService.loadConfig(repoRoot);
-            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
-            await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
-            return updated;
+            if (role === HARNESS_ENGINEER_ROLE) {
+                void taskSlug;
+                const current = await getProjectToolSessionView(repoRoot, HARNESS_ENGINEER_ROLE);
+                return current
+                    ? markProjectToolActivityIdle(repoRoot, current, persistHarnessEngineerSession)
+                    : undefined;
+            }
+            return markTaskRoleActivityIdle(repoRoot, taskSlug, role);
         }
     };
 }

package/dist/backend/services/terminal-interrupt-service.js

@@ -0,0 +1,29 @@
+import { isVcmRoleName } from "../../shared/constants.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+export function createTerminalInterruptService(deps) {
+    return {
+        async handleManualInterrupt(sessionId) {
+            const terminalSession = deps.runtime.getSession(sessionId);
+            if (!terminalSession) {
+                return;
+            }
+            const repoRoot = terminalSession.repoRoot ?? (await deps.projectService.getCurrentProject())?.repoRoot;
+            if (!repoRoot) {
+                return;
+            }
+            await deps.sessionService.markTerminalSessionActivityIdle(repoRoot, sessionId);
+            if (!isVcmRoleName(terminalSession.role)) {
+                return;
+            }
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, terminalSession.taskSlug);
+            await deps.roundService.recordManualInterrupt({
+                repoRoot,
+                stateRepoRoot: getTaskRuntimeRepoRoot(task),
+                stateRoot: config.stateRoot,
+                taskSlug: terminalSession.taskSlug,
+                role: terminalSession.role
+            });
+        }
+    };
+}

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

@@ -13,6 +13,8 @@ const TRANSLATION_MODEL = "translator";
 const OUTPUT_TRANSLATION_BATCH_DELAY_MS = 10000;
 const TRANSCRIPT_REPLAY_GRACE_MS = 5000;
 const TRANSLATION_TASK_FEED_RETENTION_LIMIT = 2000;
+const GATEWAY_TRANSLATION_REUSE_GRACE_MS = 1500;
+const GATEWAY_TRANSLATION_REUSE_POLL_MS = 50;
 export function createTranslationService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `tr_${Date.now()}_${Math.random().toString(16).slice(2)}`);
@@ -1004,6 +1006,10 @@ export function createTranslationService(deps) {
         },
         async translateGatewayOutput(input) {
             const config = await loadConfig();
+            const reusable = await findReusableGatewayOutputTranslation(input, config);
+            if (reusable) {
+                return reusable.trim();
+            }
             const translation = await translateText({
                 repoRoot: input.repoRoot,
                 taskSlug: input.taskSlug,
@@ -1033,6 +1039,148 @@ export function createTranslationService(deps) {
             };
         }
     };
+    async function findReusableGatewayOutputTranslation(input, config) {
+        const graceDeadline = Date.now() + (input.sourceEntryIds?.length ? GATEWAY_TRANSLATION_REUSE_GRACE_MS : 0);
+        while (true) {
+            const lookup = await lookupGatewayOutputTranslation(input);
+            if (lookup.kind === "translated") {
+                return lookup.text;
+            }
+            if (lookup.kind === "active") {
+                return waitForReusableGatewayOutputTranslation(input, config);
+            }
+            if (!input.sourceEntryIds?.length || Date.now() >= graceDeadline) {
+                return undefined;
+            }
+            await delay(GATEWAY_TRANSLATION_REUSE_POLL_MS);
+        }
+    }
+    async function waitForReusableGatewayOutputTranslation(input, config) {
+        const deadline = Date.now() + config.requestTimeoutMs;
+        while (Date.now() <= deadline) {
+            const lookup = await lookupGatewayOutputTranslation(input);
+            if (lookup.kind === "translated") {
+                return lookup.text;
+            }
+            if (lookup.kind !== "active") {
+                return undefined;
+            }
+            await delay(GATEWAY_TRANSLATION_REUSE_POLL_MS);
+        }
+        throw new VcmError({
+            code: "TRANSLATION_TIMEOUT",
+            message: "Gateway output translation timed out while waiting for the existing PM reply translation.",
+            statusCode: 504
+        });
+    }
+    async function lookupGatewayOutputTranslation(input) {
+        const states = await getGatewayOutputCandidateStates(input);
+        return selectGatewayOutputTranslation(states, input);
+    }
+    async function getGatewayOutputCandidateStates(input) {
+        const states = [];
+        const seen = new Set();
+        const add = (state) => {
+            if (seen.has(state) || !isGatewayOutputCandidateState(state, input)) {
+                return;
+            }
+            seen.add(state);
+            states.push(state);
+        };
+        const roleSession = await getGatewayRoleSession(input);
+        if (roleSession) {
+            const state = await prepareCache({
+                repoRoot: roleSession.cwd,
+                baseRepoRoot: input.repoRoot,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                sessionId: roleSession.id
+            });
+            if (roleSession.status === "running") {
+                startTranscriptTail(roleSession);
+            }
+            add(state);
+        }
+        for (const state of sessionStates.values()) {
+            add(state);
+        }
+        return states;
+    }
+    async function getGatewayRoleSession(input) {
+        try {
+            return await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function isGatewayOutputCandidateState(state, input) {
+        if (state.taskSlug !== input.taskSlug || state.role !== input.role) {
+            return false;
+        }
+        return state.baseRepoRoot === input.repoRoot
+            || state.repoRoot === input.repoRoot
+            || Boolean(state.repoRoot?.startsWith(`${input.repoRoot}${path.sep}`));
+    }
+    function selectGatewayOutputTranslation(states, input) {
+        const sourceEntryIds = normalizeGatewaySourceEntryIds(input.sourceEntryIds);
+        if (sourceEntryIds.length > 0) {
+            const entries = sourceEntryIds
+                .map((entryId) => findGatewayOutputEntryById(states, input, entryId));
+            const foundEntries = entries.filter((entry) => Boolean(entry));
+            if (foundEntries.length === sourceEntryIds.length) {
+                if (foundEntries.some(isActiveTranslationEntry)) {
+                    return { kind: "active" };
+                }
+                if (foundEntries.every(isReusableGatewayOutputEntry)) {
+                    return {
+                        kind: "translated",
+                        text: foundEntries.map((entry) => entry.translatedText).join("\n\n")
+                    };
+                }
+            }
+            else if (foundEntries.some(isActiveTranslationEntry)) {
+                return { kind: "active" };
+            }
+        }
+        const normalizedSourceText = normalizeGatewaySourceText(input.text);
+        const sourceMatches = states
+            .flatMap((state) => state.entries)
+            .filter((entry) => isGatewayOutputEntry(entry, input)
+            && normalizeGatewaySourceText(entry.sourceText) === normalizedSourceText);
+        const translated = [...sourceMatches].reverse().find(isReusableGatewayOutputEntry);
+        if (translated) {
+            return { kind: "translated", text: translated.translatedText };
+        }
+        if (sourceMatches.some(isActiveTranslationEntry)) {
+            return { kind: "active" };
+        }
+        return { kind: "missing" };
+    }
+    function findGatewayOutputEntryById(states, input, entryId) {
+        for (const state of states) {
+            const entry = state.entries.find((candidate) => candidate.id === entryId && isGatewayOutputEntry(candidate, input));
+            if (entry) {
+                return entry;
+            }
+        }
+        return undefined;
+    }
+    function isGatewayOutputEntry(entry, input) {
+        return entry.taskSlug === input.taskSlug
+            && entry.role === input.role
+            && entry.direction === "cc-output-to-user"
+            && entry.sourceKind === "prose";
+    }
+    function isReusableGatewayOutputEntry(entry) {
+        return entry.status === "translated" && Boolean(entry.translatedText.trim());
+    }
+    function normalizeGatewaySourceEntryIds(sourceEntryIds) {
+        return Array.from(new Set((sourceEntryIds ?? []).map((entryId) => entryId.trim()).filter(Boolean)));
+    }
+    function normalizeGatewaySourceText(text) {
+        return text.trim();
+    }
     async function writeToCurrentRole(repoRoot, taskSlug, role, text) {
         const record = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
         if (!record || record.status !== "running") {