vibe-coding-master 0.7.41 → 0.7.43

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);
@@ -77,6 +85,7 @@ export function createRuntimeCoordinatorService(deps) {
             void reconcileCurrentProject().catch(() => undefined);
         },
         stop() {
+            deps.roleStallDetector.stop();
             if (reconcileTimer === undefined) {
                 return;
             }
@@ -88,6 +97,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

@@ -104,7 +104,12 @@ export function createSessionService(deps) {
                 VCM_RUNTIME_SESSION_TOKEN: runtimeSessionToken
             }, modelEnvironment, {
                 ...buildUsageTelemetryEnvironment(deps.apiUrl, role, model),
-                ...(roleUsesLsp(role) ? { ENABLE_LSP_TOOL: "true" } : {})
+                ...(roleUsesLsp(role)
+                    ? {
+                        ENABLE_LSP_TOOL: "true",
+                        ENABLE_TOOL_SEARCH: "false"
+                    }
+                    : {})
             }),
             cols: input.cols,
             rows: input.rows
@@ -716,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,
@@ -732,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));
@@ -1199,7 +1270,8 @@ export function createSessionService(deps) {
                     : undefined;
             }
             return markTaskRoleActivityIdle(repoRoot, taskSlug, role);
-        }
+        },
+        recoverRoleSession
     };
 }
 function toRoleSessionRecordView(record, runtime) {
@@ -1289,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) {