vibe-coding-master 0.3.8 → 0.3.9

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

@@ -147,28 +147,17 @@ export function createSessionService(deps) {
             if (!record) {
                 return undefined;
             }
-            const runtimeSession = deps.runtime.getSession(record.id);
-            if (!runtimeSession) {
-                return {
-                    ...record,
-                    status: getRecoverableStatus(record),
-                    pid: undefined,
-                    exitCode: record.exitCode ?? null
-                };
-            }
-            return {
-                ...record,
-                status: runtimeSession.status,
-                activityStatus: record.activityStatus ?? "idle",
-                pid: runtimeSession.pid,
-                lastOutputAt: runtimeSession.lastOutputAt,
-                exitCode: runtimeSession.exitCode
-            };
+            return toRoleSessionRecordView(record, deps.runtime);
         },
         async listRoleSessions(repoRoot, taskSlug) {
             const sessions = [];
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+            const persistedTaskSession = await loadPersistedTaskSessionRecord(deps.fs, taskRepoRoot, config.stateRoot, taskSlug);
             for (const role of ROLE_NAMES) {
-                const session = await this.getRoleSession(repoRoot, taskSlug, role);
+                const session = toRoleSessionRecordView(deps.registry.getByRole(taskSlug, role)
+                    ?? normalizePersistedRoleRecord(persistedTaskSession?.roles[role]?.record), deps.runtime);
                 if (session) {
                     sessions.push(session);
                 }
@@ -248,6 +237,28 @@ export function createSessionService(deps) {
         }
     };
 }
+function toRoleSessionRecordView(record, runtime) {
+    if (!record) {
+        return undefined;
+    }
+    const runtimeSession = runtime.getSession(record.id);
+    if (!runtimeSession) {
+        return {
+            ...record,
+            status: getRecoverableStatus(record),
+            pid: undefined,
+            exitCode: record.exitCode ?? null
+        };
+    }
+    return {
+        ...record,
+        status: runtimeSession.status,
+        activityStatus: record.activityStatus ?? "idle",
+        pid: runtimeSession.pid,
+        lastOutputAt: runtimeSession.lastOutputAt,
+        exitCode: runtimeSession.exitCode
+    };
+}
 async function buildCodexReviewerStartCommand(fs, taskRepoRoot, launchMode, selectedModel, selectedEffort) {
     const codexDir = resolveRepoPath(taskRepoRoot, CODEX_DIR);
     const reviewDir = resolveRepoPath(taskRepoRoot, CODEX_REVIEW_DIR);
@@ -322,12 +333,17 @@ function getHandoffArtifactPath(paths, role) {
     return undefined;
 }
 async function loadPersistedRoleRecord(fs, repoRoot, stateRoot, taskSlug, role) {
+    const current = await loadPersistedTaskSessionRecord(fs, repoRoot, stateRoot, taskSlug);
+    return normalizePersistedRoleRecord(current?.roles[role]?.record);
+}
+async function loadPersistedTaskSessionRecord(fs, repoRoot, stateRoot, taskSlug) {
     const sessionPath = getTaskSessionPath(repoRoot, stateRoot, taskSlug);
     if (!(await fs.pathExists(sessionPath))) {
         return undefined;
     }
-    const current = await fs.readJson(sessionPath);
-    const record = current.roles[role]?.record;
+    return fs.readJson(sessionPath);
+}
+function normalizePersistedRoleRecord(record) {
     const legacy = record;
     return record
         ? {

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

@@ -1,17 +1,39 @@
+import { DISPATCHABLE_ROLES, ROLE_NAMES } from "../../shared/constants.js";
+import { isOpenFileLimitError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createStatusService(deps) {
     return {
         async getTaskStatus(repoRoot, taskSlug) {
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-            const artifacts = await deps.artifactService.listArtifacts({
-                repoRoot: taskRepoRoot,
-                handoffDir: task.handoffDir
-            });
-            const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
-            const warnings = artifacts.checks
+            const warnings = [];
+            let artifacts;
+            let sessions = [];
+            try {
+                artifacts = await deps.artifactService.listArtifacts({
+                    repoRoot: taskRepoRoot,
+                    handoffDir: task.handoffDir
+                });
+            }
+            catch (error) {
+                if (!isOpenFileLimitError(error)) {
+                    throw error;
+                }
+                artifacts = degradedArtifactSummary(task.handoffDir);
+                warnings.push(`Artifacts are temporarily unavailable because the backend hit the open-files limit: ${errorMessage(error)}`);
+            }
+            try {
+                sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
+            }
+            catch (error) {
+                if (!isOpenFileLimitError(error)) {
+                    throw error;
+                }
+                warnings.push(`Role sessions are temporarily unavailable because the backend hit the open-files limit: ${errorMessage(error)}`);
+            }
+            warnings.push(...artifacts.checks
                 .filter((check) => check.status !== "ok")
-                .map((check) => `${check.path}: ${check.status}`);
+                .map((check) => `${check.path}: ${check.status}`));
             return {
                 task,
                 sessions,
@@ -21,3 +43,28 @@ export function createStatusService(deps) {
         }
     };
 }
+function degradedArtifactSummary(handoffDir) {
+    const roleCommandsDir = `${handoffDir}/role-commands`;
+    const logsDir = `${handoffDir}/logs`;
+    const messagesDir = `${handoffDir}/messages`;
+    return {
+        paths: {
+            handoffDir,
+            roleCommandsDir,
+            logsDir,
+            messagesDir,
+            roleCommandPaths: Object.fromEntries(DISPATCHABLE_ROLES.map((role) => [role, `${roleCommandsDir}/${role}.md`])),
+            roleLogPaths: Object.fromEntries(ROLE_NAMES.map((role) => [role, `${logsDir}/${role}.log`])),
+            messageRoutePaths: {},
+            architecturePlanPath: `${handoffDir}/architecture-plan.md`,
+            knownIssuesPath: `${handoffDir}/known-issues.md`,
+            reviewReportPath: `${handoffDir}/review-report.md`,
+            docsSyncReportPath: `${handoffDir}/docs-sync-report.md`,
+            finalAcceptancePath: `${handoffDir}/final-acceptance.md`
+        },
+        checks: []
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [