vibe-coding-master 0.5.6 → 0.6.1

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

@@ -23,4 +23,9 @@ export function registerGatewayRoutes(app, deps) {
     app.post("/api/gateway/binding/reset", async () => {
         return deps.gatewayService.resetBinding();
     });
+    // Arm/disarm the runtime channel-connection switch (process-local, not
+    // persisted). Returns the updated GatewayStatus.
+    app.put("/api/gateway/connection", async (request) => {
+        return deps.gatewayService.setConnectionEnabled(request.body.enabled);
+    });
 }

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

@@ -5,7 +5,7 @@ export function registerProjectRoutes(app, deps) {
     });
     app.post("/api/projects/connect", async (request) => {
         const project = await deps.projectService.connectProject(request.body);
-        await deps.translationWorkerService?.cleanupStartupRuntime(project.repoRoot);
+        await deps.runtimeRecoveryService?.recoverProject(project.repoRoot);
         return project;
     });
     app.get("/api/projects/current", async () => {

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

@@ -30,10 +30,20 @@ export function createGatewayService(deps) {
     let qrLogin = null;
     let larkRegistrationState = null;
     let lastFailedTranslation = null;
+    // Runtime channel-connection arming switch. Not persisted: every process starts
+    // disarmed. `ensurePolling` is the single chokepoint that reads it, so no
+    // self-heal path can connect the channel while this is false.
+    let connectionEnabled = false;
     function isRunning() {
         return Boolean(pollAbort && !pollAbort.signal.aborted);
     }
     async function ensurePolling() {
+        // Single chokepoint for the runtime connection switch: while disarmed, no
+        // auto-connect path (boot, getStatus/reconcile self-heal, QR success,
+        // updateSettings) may start the poll loop.
+        if (!connectionEnabled) {
+            return;
+        }
         if (isRunning()) {
             return;
         }
@@ -720,7 +730,7 @@ export function createGatewayService(deps) {
                 await enableGatewayTranslationRuntime();
             }
             await ensurePolling();
-            return deps.settings.expose(settings, isRunning());
+            return deps.settings.expose(settings, isRunning(), connectionEnabled);
         },
         async updateSettings(input) {
             const gatewayStartInput = input.enabled === true
@@ -745,15 +755,31 @@ export function createGatewayService(deps) {
             else {
                 await stopPolling();
             }
-            return deps.settings.expose(settings, isRunning());
+            return deps.settings.expose(settings, isRunning(), connectionEnabled);
         },
         async resetBinding() {
             await stopPolling();
+            // Disarm the connection switch on reset so no connection survives a
+            // binding reset.
+            connectionEnabled = false;
             lastFailedTranslation = null;
             qrLogin = null;
             larkRegistrationState = null;
             const settings = await deps.settings.resetBinding();
-            return deps.settings.expose(settings, isRunning());
+            return deps.settings.expose(settings, isRunning(), connectionEnabled);
+        },
+        async setConnectionEnabled(enabled) {
+            connectionEnabled = enabled;
+            // Armed → connect now if an account is configured; disarmed → abort the
+            // poll loop (the Lark WS closes via the abort path in waitForUpdates).
+            if (enabled) {
+                await ensurePolling();
+            }
+            else {
+                await stopPolling();
+            }
+            const settings = await deps.settings.loadSettings();
+            return deps.settings.expose(settings, isRunning(), connectionEnabled);
         },
         async startQrLogin() {
             const settings = await deps.settings.loadSettings();
@@ -921,7 +947,7 @@ export function createGatewayService(deps) {
             });
             larkRegistrationState = null;
             await ensurePolling();
-            const status = deps.settings.expose(settings, isRunning());
+            const status = deps.settings.expose(settings, isRunning(), connectionEnabled);
             return {
                 status: "confirmed",
                 appIdConfigured: Boolean(result.appId),
@@ -985,7 +1011,7 @@ export function createGatewayService(deps) {
             });
             larkRegistrationState = null;
             await ensurePolling();
-            const status = deps.settings.expose(settings, isRunning());
+            const status = deps.settings.expose(settings, isRunning(), connectionEnabled);
             return {
                 status: "confirmed",
                 appIdConfigured: true,
@@ -1013,7 +1039,9 @@ export function createGatewayService(deps) {
             const settings = await deps.settings.loadSettings();
             const account = toAccount(settings);
             const boundUserId = settings.binding.boundUserId;
-            if (!settings.enabled || !account || !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) {
                 return;
             }
             const cursorKey = `${input.taskSlug}:project-manager:${input.session.claudeSessionId}`;

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

@@ -79,11 +79,12 @@ export function createGatewaySettingsService(deps) {
                 updatedAt: now()
             });
         },
-        expose(settings, running = false) {
+        expose(settings, running = false, connectionEnabled = false) {
             return {
                 version: 1,
                 enabled: settings.enabled,
                 running,
+                connectionEnabled,
                 channel: settings.channel,
                 translationEnabled: settings.translationEnabled,
                 currentProjectId: settings.currentProjectId,

package/dist/backend/runtime/node-pty-runtime.js

@@ -28,6 +28,7 @@ export function createNodePtyTerminalRuntime(deps) {
         });
         const session = {
             id: sessionId,
+            repoRoot: input.repoRoot,
             taskSlug: input.taskSlug,
             role: input.role,
             status: "running",

package/dist/backend/server.js

@@ -31,9 +31,11 @@ import { createSessionService } from "./services/session-service.js";
 import { createMessageService } from "./services/message-service.js";
 import { createRoundService } from "./services/round-service.js";
 import { createRuntimeCoordinatorService } from "./services/runtime-coordinator-service.js";
+import { createRuntimeRecoveryService } from "./services/runtime-recovery-service.js";
 import { createStatusService } from "./services/status-service.js";
 import { createTaskService } from "./services/task-service.js";
 import { createTaskLaunchService } from "./services/task-launch-service.js";
+import { createTerminalInterruptService } from "./services/terminal-interrupt-service.js";
 import { createTranslationService } from "./services/translation-service.js";
 import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
@@ -86,7 +88,7 @@ export async function createServer(deps, options = {}) {
     });
     registerProjectRoutes(app, {
         projectService: deps.projectService,
-        translationWorkerService: deps.translationWorkerService
+        runtimeRecoveryService: deps.runtimeRecoveryService
     });
     registerHarnessRoutes(app, {
         projectService: deps.projectService,
@@ -143,7 +145,10 @@ export async function createServer(deps, options = {}) {
         translationService: deps.translationService
     });
     registerGatewayRoutes(app, { gatewayService: deps.gatewayService });
-    registerTerminalWs(app, { runtime: deps.runtime });
+    registerTerminalWs(app, {
+        runtime: deps.runtime,
+        onManualInterrupt: (sessionId) => deps.terminalInterruptService.handleManualInterrupt(sessionId)
+    });
     app.addHook("onReady", async () => {
         await cleanupRecentTranslationRuntime(deps);
         await deps.gatewayService.start();
@@ -314,6 +319,13 @@ export function createDefaultServerDeps(options = {}) {
             return (await projectService.loadConfig(repoRoot)).stateRoot;
         }
     });
+    const runtimeRecoveryService = createRuntimeRecoveryService({
+        fs,
+        runtime,
+        projectService,
+        taskService,
+        translationWorkerService
+    });
     const claudeHookService = createClaudeHookService({
         projectService,
         taskService,
@@ -329,6 +341,13 @@ export function createDefaultServerDeps(options = {}) {
         jobGuard: createJobGuardService(),
         translationWorkerService
     });
+    const terminalInterruptService = createTerminalInterruptService({
+        runtime,
+        projectService,
+        taskService,
+        sessionService,
+        roundService
+    });
     const diagnosticsService = createDiagnosticsService({
         appRoot,
         runtime,
@@ -354,6 +373,8 @@ export function createDefaultServerDeps(options = {}) {
         translationService,
         gatewayService,
         runtimeCoordinator,
+        runtimeRecoveryService,
+        terminalInterruptService,
         runtime,
         diagnosticsService
     };

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

@@ -374,6 +374,11 @@ export function createClaudeHookService(deps) {
         }
         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;
+        }
         const previousAttempt = currentRoundState.roleRecovery?.role === input.role &&
             currentRoundState.roleRecovery.status !== "failed"
             ? currentRoundState.roleRecovery.attempt

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

@@ -246,6 +246,25 @@ export function createRoundService(deps) {
         recordClaudeHookEvent(input) {
             return recordRoleTurnEvent(input);
         },
+        async recordManualInterrupt(input) {
+            return withTaskLock(input, async () => {
+                const timestamp = now();
+                const state = await load(input);
+                const next = applyManualInterrupt({
+                    state,
+                    taskSlug: input.taskSlug,
+                    role: input.role,
+                    timestamp
+                });
+                if (!manualInterruptWasApplied(state, next, input.role)) {
+                    return toSessionRoundState(state, timestamp);
+                }
+                await save(input, next);
+                clearSettleTimer(input);
+                await updateSessionStatus(input, next.currentRound?.status === "running" ? "running" : "stopped");
+                return toSessionRoundState(next, timestamp);
+            });
+        },
         async setRoleRecovery(input) {
             return withTaskLock(input, async () => {
                 const timestamp = now();
@@ -327,6 +346,7 @@ function applyPromptSubmitted(input) {
             lastTurnStartedAt: input.timestamp,
             settleDeadlineAt: undefined,
             stoppedAt: undefined,
+            stopReason: undefined,
             activeTurnStartedAt: current.activeTurnStartedAt ?? input.timestamp,
             turnCount: current.turnCount + 1,
             roles: appendUniqueRole(current.roles, input.role)
@@ -360,6 +380,7 @@ function applyStop(input) {
         activeRole: input.role,
         lastTurnEndedAt: input.timestamp,
         settleDeadlineAt: addMilliseconds(input.timestamp, input.settleMs),
+        stopReason: undefined,
         activeTurnStartedAt: undefined,
         ccActiveMs: current.ccActiveMs + activeDurationMs,
         completedTurnCount: current.completedTurnCount + 1,
@@ -374,6 +395,47 @@ function applyStop(input) {
         updatedAt: input.timestamp
     };
 }
+function applyManualInterrupt(input) {
+    const current = input.state.currentRound;
+    if (!current || current.status === "stopped" || !current.activeTurnStartedAt || current.activeRole !== input.role) {
+        return {
+            ...input.state,
+            taskSlug: input.taskSlug,
+            updatedAt: input.timestamp
+        };
+    }
+    const activeDurationMs = getDurationMs(current.activeTurnStartedAt, input.timestamp);
+    const stopped = {
+        ...current,
+        status: "stopped",
+        activeRole: input.role,
+        lastTurnEndedAt: input.timestamp,
+        stoppedAt: input.timestamp,
+        stopReason: "manual-interrupt",
+        settleDeadlineAt: undefined,
+        activeTurnStartedAt: undefined,
+        ccActiveMs: current.ccActiveMs + activeDurationMs,
+        completedTurnCount: current.completedTurnCount + 1,
+        roles: appendUniqueRole(current.roles, input.role)
+    };
+    return {
+        ...input.state,
+        taskSlug: input.taskSlug,
+        currentRound: stopped,
+        lastStoppedRound: stopped,
+        totalCompletedTurnCount: input.state.totalCompletedTurnCount + 1,
+        totalCcActiveMs: input.state.totalCcActiveMs + activeDurationMs,
+        pendingUserReply: undefined,
+        updatedAt: input.timestamp
+    };
+}
+function manualInterruptWasApplied(previous, next, role) {
+    return Boolean(previous.currentRound?.status === "running"
+        && previous.currentRound.activeTurnStartedAt
+        && previous.currentRound.activeRole === role
+        && next.currentRound?.stopReason === "manual-interrupt"
+        && next.currentRound.status === "stopped");
+}
 function toSessionRoundState(state, updatedAt) {
     const current = state.currentRound;
     if (!current) {
@@ -407,6 +469,7 @@ function toSessionRoundState(state, updatedAt) {
         lastTurnEndedAt: current.lastTurnEndedAt,
         settleDeadlineAt: current.settleDeadlineAt,
         stoppedAt: current.stoppedAt,
+        stopReason: current.stopReason,
         activeTurnStartedAt: current.activeTurnStartedAt,
         roundSequence: current.sequence,
         turnCount: current.turnCount,
@@ -439,8 +502,10 @@ function computeFlowPause(current, roleRecovery, awaitingUser) {
         return undefined;
     }
     const roundStopped = Boolean(current) && current.status === "stopped" && Boolean(current.id);
+    const nonAlertingStop = roundStopped && (current.stopReason === "manual-interrupt" ||
+        current.stopReason === "runtime-recovery");
     if (roleRecovery?.status === "failed") {
-        return roundStopped
+        return roundStopped && !nonAlertingStop
             ? {
                 paused: true,
                 reason: "role-recovery-failed",
@@ -459,7 +524,7 @@ function computeFlowPause(current, roleRecovery, awaitingUser) {
             messageTruncated: awaitingUser.messageTruncated
         };
     }
-    if (roundStopped) {
+    if (roundStopped && !nonAlertingStop) {
         return {
             paused: true,
             reason: "stopped-no-next-turn",
@@ -633,6 +698,9 @@ function normalizeRound(input) {
             : typeof legacy.pausedAt === "string"
                 ? legacy.pausedAt
                 : undefined,
+        stopReason: input.stopReason === "manual-interrupt" || input.stopReason === "runtime-recovery"
+            ? input.stopReason
+            : undefined,
         activeTurnStartedAt: typeof input.activeTurnStartedAt === "string"
             ? input.activeTurnStartedAt
             : typeof legacy.runningSince === "string"

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)}`);
+    }
+}