vibe-coding-master 0.7.42 → 0.7.44

package/dist/backend/services/role-stall-detector-service.js

@@ -0,0 +1,322 @@
+import { isVcmRoleName } from "../../shared/constants.js";
+import { VcmError } from "../errors.js";
+export const ROLE_MODEL_STALL_TIMEOUT_MS = 10 * 60 * 1000;
+export const ROLE_TOOL_STALL_TIMEOUT_MS = 10 * 60 * 1000;
+export const ROLE_SUBAGENT_STALL_TIMEOUT_MS = 30 * 60 * 1000;
+const TOOL_TIMEOUT_GRACE_MS = 30_000;
+export function createRoleStallDetectorService(deps) {
+    const modelTimeoutMs = deps.modelTimeoutMs ?? ROLE_MODEL_STALL_TIMEOUT_MS;
+    const toolTimeoutMs = deps.toolTimeoutMs ?? ROLE_TOOL_STALL_TIMEOUT_MS;
+    const subagentTimeoutMs = deps.subagentTimeoutMs ?? ROLE_SUBAGENT_STALL_TIMEOUT_MS;
+    const now = deps.now ?? (() => new Date().toISOString());
+    const setTimer = deps.setTimeout ?? ((callback, delayMs) => globalThis.setTimeout(callback, delayMs));
+    const clearTimer = deps.clearTimeout ?? ((timer) => globalThis.clearTimeout(timer));
+    const monitors = new Map();
+    return {
+        async recordHook(input) {
+            if (!isVcmRoleName(input.role)) {
+                return;
+            }
+            const key = monitorKey(input.repoRoot, input.taskSlug);
+            if (input.eventName === "Stop" || input.eventName === "StopFailure") {
+                clearMonitor(key);
+                return;
+            }
+            const [session, round] = await Promise.all([
+                deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role),
+                deps.roundService.getSessionRoundState(roundInput(input))
+            ]);
+            if (!session
+                || session.status !== "running"
+                || session.activityStatus !== "running"
+                || round.status !== "running"
+                || round.activeRole !== input.role
+                || !round.roundId) {
+                clearMonitor(key);
+                return;
+            }
+            let monitor = monitors.get(key);
+            if (!monitor
+                || monitor.sessionId !== session.id
+                || monitor.runtimeSessionToken !== session.runtimeSessionToken
+                || monitor.roundId !== round.roundId
+                || monitor.role !== input.role) {
+                clearMonitor(key);
+                monitor = {
+                    context: taskInput(input),
+                    role: input.role,
+                    sessionId: session.id,
+                    runtimeSessionToken: session.runtimeSessionToken,
+                    roundId: round.roundId,
+                    phase: "awaiting-model",
+                    phaseStartedAt: now(),
+                    generation: 0,
+                    activeTools: new Map()
+                };
+                monitors.set(key, monitor);
+            }
+            advanceMonitor(key, monitor, input.eventName, input.event);
+        },
+        async reconcileTask(input) {
+            const key = monitorKey(input.repoRoot, input.taskSlug);
+            for (const [candidateKey, monitor] of monitors) {
+                if (monitor.context.repoRoot === input.repoRoot && candidateKey !== key) {
+                    clearMonitor(candidateKey);
+                }
+            }
+            const monitor = monitors.get(key);
+            if (!monitor) {
+                return;
+            }
+            const [session, round] = await Promise.all([
+                deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, monitor.role),
+                deps.roundService.getSessionRoundState(roundInput(input))
+            ]);
+            if (!session
+                || session.id !== monitor.sessionId
+                || session.runtimeSessionToken !== monitor.runtimeSessionToken
+                || session.status !== "running"
+                || session.activityStatus !== "running"
+                || round.status !== "running"
+                || round.activeRole !== monitor.role
+                || round.roundId !== monitor.roundId) {
+                clearMonitor(key);
+            }
+        },
+        getWarning(repoRoot, taskSlug) {
+            const warning = monitors.get(monitorKey(repoRoot, taskSlug))?.warning;
+            return warning ? { ...warning } : null;
+        },
+        ignoreWarning(repoRoot, taskSlug, warningId) {
+            const monitor = requireWarning(repoRoot, taskSlug, warningId);
+            monitor.ignoredGeneration = monitor.generation;
+            monitor.warning = undefined;
+            cancelTimer(monitor);
+            return { ok: true, warning: null };
+        },
+        async recoverWarning(input) {
+            const key = monitorKey(input.repoRoot, input.taskSlug);
+            const monitor = requireWarning(input.repoRoot, input.taskSlug, input.warningId);
+            const [session, round] = await Promise.all([
+                deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, monitor.role),
+                deps.roundService.getSessionRoundState(roundInput(input))
+            ]);
+            if (!session
+                || session.id !== monitor.sessionId
+                || session.runtimeSessionToken !== monitor.runtimeSessionToken
+                || session.status !== "running"
+                || session.activityStatus !== "running"
+                || round.status !== "running"
+                || round.activeRole !== monitor.role
+                || round.roundId !== monitor.roundId) {
+                clearMonitor(key);
+                return { ok: true, warning: null };
+            }
+            await deps.sessionService.recoverRoleSession(input.repoRoot, input.taskSlug, {
+                role: monitor.role,
+                expectedSessionId: monitor.sessionId,
+                expectedRuntimeSessionToken: monitor.runtimeSessionToken,
+                recoveryPrompt: renderRecoveryPrompt(monitor)
+            });
+            clearMonitor(key);
+            return { ok: true, warning: null };
+        },
+        clearProject(repoRoot) {
+            for (const [key, monitor] of monitors) {
+                if (monitor.context.repoRoot === repoRoot) {
+                    clearMonitor(key);
+                }
+            }
+        },
+        stop() {
+            for (const key of [...monitors.keys()]) {
+                clearMonitor(key);
+            }
+        }
+    };
+    function advanceMonitor(key, monitor, eventName, event) {
+        monitor.generation += 1;
+        monitor.warning = undefined;
+        monitor.ignoredGeneration = undefined;
+        cancelTimer(monitor);
+        switch (eventName) {
+            case "UserPromptSubmit":
+            case "PostCompact":
+            case "PostToolBatch":
+                monitor.activeTools.clear();
+                monitor.currentTool = undefined;
+                setPhase(key, monitor, "awaiting-model", modelTimeoutMs);
+                return;
+            case "PreToolUse": {
+                const tool = readTool(event, toolTimeoutMs, subagentTimeoutMs);
+                const toolKey = tool.toolUseId ?? `anonymous-${monitor.generation}`;
+                monitor.activeTools.set(toolKey, tool);
+                monitor.currentTool = tool;
+                setPhase(key, monitor, tool.toolName === "Agent" ? "subagent-running" : "tool-running", tool.timeoutMs);
+                return;
+            }
+            case "SubagentStart":
+                setPhase(key, monitor, "subagent-running", subagentTimeoutMs);
+                return;
+            case "PostToolUse":
+            case "PostToolUseFailure": {
+                const toolUseId = stringValue(event.tool_use_id);
+                if (toolUseId) {
+                    monitor.activeTools.delete(toolUseId);
+                }
+                monitor.currentTool = firstTool(monitor.activeTools);
+                if (monitor.currentTool) {
+                    setPhase(key, monitor, monitor.currentTool.toolName === "Agent" ? "subagent-running" : "tool-running", monitor.currentTool.timeoutMs);
+                }
+                return;
+            }
+            case "SubagentStop":
+                monitor.currentTool = firstTool(monitor.activeTools);
+                if (monitor.currentTool) {
+                    setPhase(key, monitor, monitor.currentTool.toolName === "Agent" ? "subagent-running" : "tool-running", monitor.currentTool.timeoutMs);
+                }
+                return;
+            case "PreCompact":
+                monitor.activeTools.clear();
+                monitor.currentTool = undefined;
+                setPhase(key, monitor, "compacting", modelTimeoutMs);
+                return;
+            case "PermissionRequest":
+                setPhase(key, monitor, "awaiting-permission");
+                return;
+            default:
+                return;
+        }
+    }
+    function setPhase(key, monitor, phase, timeoutMs) {
+        monitor.phase = phase;
+        monitor.phaseStartedAt = now();
+        if (timeoutMs === undefined) {
+            return;
+        }
+        const generation = monitor.generation;
+        monitor.timer = setTimer(() => {
+            void detectStall(key, generation).catch(() => undefined);
+        }, timeoutMs);
+    }
+    async function detectStall(key, generation) {
+        const monitor = monitors.get(key);
+        if (!monitor || monitor.generation !== generation || monitor.ignoredGeneration === generation) {
+            return;
+        }
+        const [session, round] = await Promise.all([
+            deps.sessionService.getRoleSession(monitor.context.repoRoot, monitor.context.taskSlug, monitor.role),
+            deps.roundService.getSessionRoundState(roundInput(monitor.context))
+        ]);
+        if (!session
+            || session.id !== monitor.sessionId
+            || session.runtimeSessionToken !== monitor.runtimeSessionToken
+            || session.status !== "running"
+            || session.activityStatus !== "running"
+            || round.status !== "running"
+            || round.activeRole !== monitor.role
+            || round.roundId !== monitor.roundId) {
+            clearMonitor(key);
+            return;
+        }
+        const detectedAt = now();
+        monitor.timer = undefined;
+        monitor.warning = {
+            id: `${monitor.sessionId}:${monitor.roundId}:${generation}:${detectedAt}`,
+            taskSlug: monitor.context.taskSlug,
+            role: monitor.role,
+            sessionId: monitor.sessionId,
+            runtimeSessionToken: monitor.runtimeSessionToken,
+            roundId: monitor.roundId,
+            phase: monitor.phase,
+            phaseStartedAt: monitor.phaseStartedAt,
+            detectedAt,
+            toolUseId: monitor.currentTool?.toolUseId,
+            toolName: monitor.currentTool?.toolName
+        };
+    }
+    function requireWarning(repoRoot, taskSlug, warningId) {
+        const monitor = monitors.get(monitorKey(repoRoot, taskSlug));
+        if (!monitor?.warning || monitor.warning.id !== warningId) {
+            throw new VcmError({
+                code: "ROLE_STALL_WARNING_STALE",
+                message: "The role stall warning is no longer active.",
+                statusCode: 409,
+                hint: "Refresh the task workspace before retrying the action."
+            });
+        }
+        return monitor;
+    }
+    function cancelTimer(monitor) {
+        if (monitor.timer === undefined) {
+            return;
+        }
+        clearTimer(monitor.timer);
+        monitor.timer = undefined;
+    }
+    function clearMonitor(key) {
+        const monitor = monitors.get(key);
+        if (!monitor) {
+            return;
+        }
+        cancelTimer(monitor);
+        monitors.delete(key);
+    }
+}
+function monitorKey(repoRoot, taskSlug) {
+    return `${repoRoot}:${taskSlug}`;
+}
+function taskInput(input) {
+    return {
+        repoRoot: input.repoRoot,
+        taskRepoRoot: input.taskRepoRoot,
+        stateRoot: input.stateRoot,
+        taskSlug: input.taskSlug
+    };
+}
+function roundInput(input) {
+    return {
+        repoRoot: input.repoRoot,
+        stateRepoRoot: input.taskRepoRoot,
+        stateRoot: input.stateRoot,
+        taskSlug: input.taskSlug
+    };
+}
+function readTool(event, defaultTimeoutMs, subagentTimeoutMs) {
+    const toolName = stringValue(event.tool_name);
+    const toolUseId = stringValue(event.tool_use_id);
+    const input = objectValue(event.tool_input);
+    const requestedTimeout = numberValue(input?.timeout);
+    return {
+        toolName,
+        toolUseId,
+        timeoutMs: toolName === "Agent"
+            ? subagentTimeoutMs
+            : Math.max(defaultTimeoutMs, requestedTimeout ? requestedTimeout + TOOL_TIMEOUT_GRACE_MS : 0)
+    };
+}
+function firstTool(tools) {
+    return tools.values().next().value;
+}
+function renderRecoveryPrompt(monitor) {
+    const phase = monitor.currentTool?.toolName
+        ? `${monitor.phase} (${monitor.currentTool.toolName})`
+        : monitor.phase;
+    return [
+        "[VCM Session Recovery]",
+        `The previous ${monitor.role} turn may have stalled during ${phase}.`,
+        "Continue the current assigned work from the existing Claude session context.",
+        "Do not repeat completed work unless it is needed to verify the current state."
+    ].join("\n");
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}

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

@@ -280,6 +280,31 @@ export function createRoundService(deps) {
                 return toSessionRoundState(next, timestamp);
             });
         },
+        async recordRoleRecoveryFailure(input) {
+            return withTaskLock(input, async () => {
+                const timestamp = now();
+                const state = await load(input);
+                const stopped = applyTerminalExit({
+                    state,
+                    taskSlug: input.taskSlug,
+                    role: input.recovery.role,
+                    timestamp
+                });
+                const next = {
+                    ...stopped,
+                    roleRecovery: normalizeRoleRecovery({
+                        ...input.recovery,
+                        status: "failed",
+                        failedAt: input.recovery.failedAt ?? timestamp
+                    }),
+                    updatedAt: 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();

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

@@ -42,9 +42,17 @@ export function createRuntimeCoordinatorService(deps) {
             ]);
             const preferences = await deps.appSettings.getPreferences();
             if (!activeTask) {
+                deps.roleStallDetector.clearProject(repoRoot);
                 return { activeTask: null, gatewayStatus };
             }
             const taskRepoRoot = getTaskRuntimeRepoRoot(activeTask);
+            const stateRoot = await deps.getStateRoot(repoRoot);
+            await deps.roleStallDetector.reconcileTask({
+                repoRoot,
+                taskRepoRoot,
+                stateRoot,
+                taskSlug: activeTask.taskSlug
+            });
             const harnessInitialized = await deps.harnessService.getHarnessStatus(taskRepoRoot)
                 .then((status) => status.initialized)
                 .catch(() => false);
@@ -58,7 +66,8 @@ export function createRuntimeCoordinatorService(deps) {
             else {
                 await deps.translationService.stopTask(taskRepoRoot, activeTask.taskSlug).catch(() => undefined);
             }
-            await reconcileAutoMemory(repoRoot, activeTask, preferences.autoTaskHarnessReviewEnabled ? "auto" : undefined);
+            const memoryState = await reconcileAutoMemory(repoRoot, activeTask, preferences.autoTaskHarnessReviewEnabled ? "auto" : undefined);
+            await deps.harnessFeedbackService.completeWaitingTaskRetrospective(repoRoot, activeTask.taskSlug, memoryState.status);
             const memoryReadiness = await getTaskRetrospectiveMemoryReadiness(repoRoot, activeTask);
             if ((preferences.autoTaskHarnessReviewEnabled || memoryReadiness.trigger) && memoryReadiness.ready) {
                 await maybeStartTaskHarnessRetrospective(repoRoot, activeTask, memoryReadiness.trigger ?? "auto");
@@ -77,6 +86,7 @@ export function createRuntimeCoordinatorService(deps) {
             void reconcileCurrentProject().catch(() => undefined);
         },
         stop() {
+            deps.roleStallDetector.stop();
             if (reconcileTimer === undefined) {
                 return;
             }
@@ -88,6 +98,7 @@ export function createRuntimeCoordinatorService(deps) {
     async function reconcileCurrentProject() {
         const project = await deps.projectService.getCurrentProject();
         if (!project) {
+            deps.roleStallDetector.stop();
             return;
         }
         await reconcileProject(project.repoRoot);

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

@@ -721,7 +721,8 @@ export function createSessionService(deps) {
             return undefined;
         }
         const timestamp = now();
-        const turnWasRunning = current.activityStatus === "running";
+        const turnWasRunning = current.activityStatus === "running"
+            && current.expectedRuntimeExitReason !== "role-stall-recovery";
         const updated = {
             ...current,
             status: input.status,
@@ -737,6 +738,71 @@ export function createSessionService(deps) {
         await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
         return { record: updated, turnWasRunning };
     }
+    async function persistTaskRoleRecord(repoRoot, taskSlug, record) {
+        deps.registry.upsert(record);
+        const config = await deps.projectService.loadConfig(repoRoot);
+        const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+        await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, record);
+        return record;
+    }
+    async function recoverRoleSession(repoRoot, taskSlug, input) {
+        const current = await getTaskRoleSessionView(repoRoot, taskSlug, input.role);
+        if (!current
+            || current.id !== input.expectedSessionId
+            || current.runtimeSessionToken !== input.expectedRuntimeSessionToken
+            || current.status !== "running"
+            || current.activityStatus !== "running") {
+            throw new VcmError({
+                code: "ROLE_STALL_SESSION_CHANGED",
+                message: `${input.role} session changed before recovery could begin.`,
+                statusCode: 409
+            });
+        }
+        if (!current.claudeSessionId) {
+            throw new VcmError({
+                code: "CLAUDE_SESSION_MISSING",
+                message: `${input.role} does not have a confirmed Claude session id to resume.`,
+                statusCode: 409
+            });
+        }
+        const prepared = await persistTaskRoleRecord(repoRoot, taskSlug, {
+            ...current,
+            expectedRuntimeExitReason: "role-stall-recovery",
+            updatedAt: now()
+        });
+        if (deps.runtime.getSession(prepared.id)) {
+            await deps.runtime.stop(prepared.id);
+        }
+        await persistTaskRoleRecord(repoRoot, taskSlug, {
+            ...prepared,
+            status: "exited",
+            activityStatus: "idle",
+            pid: undefined,
+            expectedRuntimeExitReason: undefined,
+            updatedAt: now()
+        });
+        const resumed = await launchRoleSession(repoRoot, taskSlug, input.role, {
+            permissionMode: prepared.permissionMode,
+            model: prepared.model,
+            effort: prepared.effort
+        }, "resume");
+        if ((await waitForSessionInputReady(resumed.id)) === "exited") {
+            throw new VcmError({
+                code: "ROLE_STALL_RESUME_FAILED",
+                message: `${input.role} session exited before recovery input could be submitted.`,
+                statusCode: 409
+            });
+        }
+        await submitTerminalInput(deps.runtime, resumed.id, input.recoveryPrompt);
+        return persistTaskRoleRecord(repoRoot, taskSlug, {
+            ...resumed,
+            activityStatus: "running",
+            lastTurnStartedAt: now(),
+            lastHookEventAt: now(),
+            expectedRuntimeExitReason: undefined,
+            updatedAt: now()
+        });
+    }
     return {
         async assertModelLaunchReady(model = "default") {
             await getModelLaunchEnvironment(normalizeClaudeModel(model));
@@ -1204,7 +1270,8 @@ export function createSessionService(deps) {
                     : undefined;
             }
             return markTaskRoleActivityIdle(repoRoot, taskSlug, role);
-        }
+        },
+        recoverRoleSession
     };
 }
 function toRoleSessionRecordView(record, runtime) {
@@ -1294,7 +1361,7 @@ function isSessionMissingError(error) {
         error.code === "SESSION_MISSING";
 }
 function withoutRuntimeOnlySessionFields(session) {
-    const { pid: _pid, runtimeSessionToken: _runtimeSessionToken, ...persisted } = session;
+    const { pid: _pid, runtimeSessionToken: _runtimeSessionToken, expectedRuntimeExitReason: _expectedRuntimeExitReason, ...persisted } = session;
     return persisted;
 }
 function defaultIsProcessAlive(pid) {

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

@@ -59,6 +59,7 @@ function degradedArtifactSummary(handoffDir) {
             architectDebugPath: `${handoffDir}/architect-debug.md`,
             architectureDiagnosisPath: `${handoffDir}/architecture-diagnosis.md`,
             testReportPath: `${handoffDir}/test-report.md`,
+            docsUpdateReportPath: `${handoffDir}/docs-update-report.md`,
             docsSyncReportPath: `${handoffDir}/docs-sync-report.md`,
             workflowProgressPath: `${handoffDir}/workflow-progress.md`,
             finalAcceptancePath: `${handoffDir}/final-acceptance.md`

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

@@ -214,14 +214,23 @@ export function createTranslationWorkerService(deps) {
             }
             const session = await ensureTranslatorSession(repoRoot, next.targetLanguage, next.taskSlug);
             await submitTerminalInput(deps.runtime, session.id, batch?.prompt ?? await buildQueuePrompt(repoRoot, next));
+            const latestQueue = await loadQueue(repoRoot);
+            if (latestQueue.activeItemId !== next.id) {
+                return;
+            }
+            const dispatchedItems = latestQueue.items.filter((item) => item.status === "dispatching" &&
+                (batch ? item.batchId === batch.items[0]?.batchId : item.id === next.id));
+            if (dispatchedItems.length === 0) {
+                return;
+            }
             const dispatchedAt = now();
-            for (const item of batch?.items ?? [next]) {
+            for (const item of dispatchedItems) {
                 item.status = "running";
                 item.updatedAt = dispatchedAt;
             }
-            queue.updatedAt = dispatchedAt;
-            await saveQueue(repoRoot, queue);
-            await Promise.all((batch?.items ?? [next]).map((item) => syncJobStatus(repoRoot, item)));
+            latestQueue.updatedAt = dispatchedAt;
+            await saveQueue(repoRoot, latestQueue);
+            await Promise.all(dispatchedItems.map((item) => syncJobStatus(repoRoot, item)));
         }
         catch (error) {
             const failedItems = queue.activeItemId === next.id
@@ -438,6 +447,12 @@ export function createTranslationWorkerService(deps) {
             await validateActiveQueueItem(repoRoot);
             return true;
         }
+        // `dispatching` covers the interval between writing the prompt and the
+        // Translator's UserPromptSubmit hook. The role session is legitimately idle
+        // during that interval, so only an actual result can reconcile the item.
+        if (active.status === "dispatching") {
+            return false;
+        }
         if (await translatorSessionSettled(repoRoot, active.taskSlug)) {
             await validateActiveQueueItem(repoRoot);
             return true;