vibe-coding-master 0.7.24 → 0.7.26

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

@@ -3,6 +3,7 @@ import { VcmError } from "../errors.js";
 export const TERMINAL_REPLAY_TAIL_LIMIT_BYTES = 2 * 1024 * 1024;
 export function createNodePtyTerminalRuntime(deps) {
     const entries = new Map();
+    const processExitListeners = new Set();
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `session_${Date.now()}_${Math.random().toString(16).slice(2)}`);
     const emit = (entry, event) => {
@@ -68,6 +69,12 @@ export function createNodePtyTerminalRuntime(deps) {
             if (!disposeEntry(entries, entry, exitCode === 0 ? "exited" : "crashed", exitCode)) {
                 return;
             }
+            for (const listener of processExitListeners) {
+                listener({
+                    session: { ...entry.session },
+                    exitCode
+                });
+            }
             emit(entry, {
                 sessionId: session.id,
                 taskSlug: input.taskSlug,
@@ -117,14 +124,16 @@ export function createNodePtyTerminalRuntime(deps) {
         },
         async stop(sessionId) {
             const entry = getEntry(entries, sessionId);
+            const exitCode = entry.session.exitCode ?? null;
+            const disposed = disposeEntry(entries, entry, "exited", exitCode);
             entry.process.kill();
-            if (disposeEntry(entries, entry, "exited", entry.session.exitCode ?? null)) {
+            if (disposed) {
                 emit(entry, {
                     sessionId,
                     taskSlug: entry.session.taskSlug,
                     role: entry.session.role,
                     type: "exit",
-                    exitCode: entry.session.exitCode ?? null
+                    exitCode
                 });
                 entry.listeners.clear();
             }
@@ -132,8 +141,8 @@ export function createNodePtyTerminalRuntime(deps) {
         },
         async restart(sessionId) {
             const entry = getEntry(entries, sessionId);
-            entry.process.kill();
             disposeEntry(entries, entry, "exited", entry.session.exitCode ?? null);
+            entry.process.kill();
             entry.listeners.clear();
             await entry.logWriter.close();
             return create(entry.input, sessionId);
@@ -175,6 +184,12 @@ export function createNodePtyTerminalRuntime(deps) {
             return () => {
                 entry.listeners.delete(listener);
             };
+        },
+        subscribeProcessExits(listener) {
+            processExitListeners.add(listener);
+            return () => {
+                processExitListeners.delete(listener);
+            };
         }
     };
 }

package/dist/backend/server.js

@@ -42,9 +42,9 @@ import { createTaskCloseService } from "./services/task-close-service.js";
 import { createTaskWorkflowService } from "./services/task-workflow-service.js";
 import { createTaskLaunchService } from "./services/task-launch-service.js";
 import { createTerminalInterruptService } from "./services/terminal-interrupt-service.js";
+import { createTerminalProcessExitService } from "./services/terminal-process-exit-service.js";
 import { createTranslationService } from "./services/translation-service.js";
 import { createUsageAnalyticsService } from "./services/usage-analytics-service.js";
-import { createTurnReconcilerService } from "./services/turn-reconciler-service.js";
 import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
 import { registerArtifactRoutes } from "./api/artifact-routes.js";
@@ -174,10 +174,12 @@ export async function createServer(deps, options = {}) {
     app.addHook("onReady", async () => {
         await deps.ccrIntegration.initialize();
         await cleanupRecentTranslationRuntime(deps);
+        deps.terminalProcessExitService.start();
         deps.runtimeCoordinator.start();
         await deps.gatewayService.start();
     });
     app.addHook("onClose", async () => {
+        deps.terminalProcessExitService.stop();
         deps.runtimeCoordinator.stop();
         await deps.gatewayService.stop();
     });
@@ -390,11 +392,6 @@ export function createDefaultServerDeps(options = {}) {
         translationWorkerService,
         architectRestartService
     });
-    const turnReconciler = createTurnReconcilerService({
-        sessionService,
-        roundService,
-        claudeHookService
-    });
     const runtimeCoordinator = createRuntimeCoordinatorService({
         appSettings,
         projectService,
@@ -406,7 +403,6 @@ export function createDefaultServerDeps(options = {}) {
         autoMemoryService,
         roundService,
         gatewayService,
-        turnReconciler,
         async getStateRoot(repoRoot) {
             return (await projectService.loadConfig(repoRoot)).stateRoot;
         }
@@ -418,6 +414,13 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         roundService
     });
+    const terminalProcessExitService = createTerminalProcessExitService({
+        runtime,
+        projectService,
+        taskService,
+        sessionService,
+        roundService
+    });
     const diagnosticsService = createDiagnosticsService({
         appRoot,
         runtime,
@@ -450,6 +453,7 @@ export function createDefaultServerDeps(options = {}) {
         runtimeCoordinator,
         runtimeRecoveryService,
         terminalInterruptService,
+        terminalProcessExitService,
         runtime,
         diagnosticsService,
         usageAnalyticsService

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

@@ -837,18 +837,6 @@ export function createClaudeHookService(deps) {
                 return processStopHook(input, { allowBlock: true });
             });
         },
-        handleReconciledTurnEnd(input) {
-            return withRoleHookLock(input, async () => {
-                const eventName = parseHookEvent(input.event.hook_event_name);
-                if (eventName === "Stop") {
-                    return processStopHook(input, { allowBlock: false });
-                }
-                if (eventName === "StopFailure") {
-                    return processStopFailureHook(input);
-                }
-                throwUnsupportedEvent(eventName);
-            });
-        },
         handlePermissionRequestHook
     };
 }

package/dist/backend/services/gate-review-service.js

@@ -12,7 +12,6 @@ const REQUESTS_DIR = ".ai/vcm/gate-reviews/requests";
 const GATE_REVIEW_VERSION = 1;
 const REVIEWER_ROLE = "reviewer";
 const DEFAULT_REPORT_POLL_INTERVAL_MS = 1000;
-const DEFAULT_REPORT_TIMEOUT_MS = 30 * 60 * 1000;
 const activeRuns = new Set();
 const ARCHITECTURE_ANALYSIS_FIELDS = [
     "Evidence Read",
@@ -92,7 +91,6 @@ const VALID_SEVERITIES = new Set(["critical", "high", "medium", "low"]);
 export function createGateReviewService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const reportPollIntervalMs = deps.reportPollIntervalMs ?? DEFAULT_REPORT_POLL_INTERVAL_MS;
-    const reportTimeoutMs = deps.reportTimeoutMs ?? DEFAULT_REPORT_TIMEOUT_MS;
     async function getContext(repoRoot, taskSlug) {
         const projectConfig = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
@@ -457,10 +455,7 @@ export function createGateReviewService(deps) {
                 role: REVIEWER_ROLE,
                 eventName: "UserPromptSubmit"
             });
-            const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), {
-                intervalMs: reportPollIntervalMs,
-                timeoutMs: reportTimeoutMs
-            });
+            const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), reportPollIntervalMs);
             const completedAt = now();
             await updateRequestStatus(deps.fs, context, requestId, "completed", {
                 completedAt,
@@ -1093,28 +1088,18 @@ Decision: approve|request_changes
 Summary: <one or two sentences>
 [/VCM GATE REVIEW]`;
 }
-async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, options) {
-    const startedAt = Date.now();
-    let lastError;
-    while (Date.now() - startedAt <= options.timeoutMs) {
+async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, intervalMs) {
+    while (true) {
         try {
             return await parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp);
         }
         catch (error) {
-            lastError = error;
             if (!isPendingReportError(error)) {
                 throw error;
             }
         }
-        await delay(options.intervalMs);
+        await delay(intervalMs);
     }
-    const detail = errorMessage(lastError);
-    throw new VcmError({
-        code: "GATE_REVIEW_REPORT_TIMEOUT",
-        message: `Reviewer did not produce a valid ${gate} report within ${Math.round(options.timeoutMs / 1000)}s.`,
-        statusCode: 504,
-        hint: detail
-    });
 }
 async function parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp) {
     const reportPath = reportPathForGate(gate);

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

@@ -261,6 +261,25 @@ export function createRoundService(deps) {
                 return toSessionRoundState(next, timestamp);
             });
         },
+        async recordTerminalExit(input) {
+            return withTaskLock(input, async () => {
+                const timestamp = now();
+                const state = await load(input);
+                const next = applyTerminalExit({
+                    state,
+                    taskSlug: input.taskSlug,
+                    role: input.role,
+                    timestamp
+                });
+                if (!terminalExitWasApplied(state, next, input.role)) {
+                    return toSessionRoundState(state, timestamp);
+                }
+                await save(input, next);
+                clearSettleTimer(input);
+                await updateSessionStatus(input, "stopped");
+                return toSessionRoundState(next, timestamp);
+            });
+        },
         async setRoleRecovery(input) {
             return withTaskLock(input, async () => {
                 const timestamp = now();
@@ -392,6 +411,16 @@ function applyStop(input) {
     };
 }
 function applyManualInterrupt(input) {
+    return applyForcedTurnStop(input, "manual-interrupt");
+}
+function applyTerminalExit(input) {
+    const stopped = applyForcedTurnStop(input, "terminal-exit");
+    return stopped.currentRound?.stopReason === "terminal-exit"
+        && stopped.roleRecovery?.role === input.role
+        ? { ...stopped, roleRecovery: undefined }
+        : stopped;
+}
+function applyForcedTurnStop(input, stopReason) {
     const current = input.state.currentRound;
     if (!current || current.status === "stopped" || !current.activeTurnStartedAt || current.activeRole !== input.role) {
         return {
@@ -407,7 +436,7 @@ function applyManualInterrupt(input) {
         activeRole: input.role,
         lastTurnEndedAt: input.timestamp,
         stoppedAt: input.timestamp,
-        stopReason: "manual-interrupt",
+        stopReason,
         settleDeadlineAt: undefined,
         activeTurnStartedAt: undefined,
         ccActiveMs: current.ccActiveMs + activeDurationMs,
@@ -431,6 +460,13 @@ function manualInterruptWasApplied(previous, next, role) {
         && next.currentRound?.stopReason === "manual-interrupt"
         && next.currentRound.status === "stopped");
 }
+function terminalExitWasApplied(previous, next, role) {
+    return Boolean(previous.currentRound?.status === "running"
+        && previous.currentRound.activeTurnStartedAt
+        && previous.currentRound.activeRole === role
+        && next.currentRound?.stopReason === "terminal-exit"
+        && next.currentRound.status === "stopped");
+}
 function toSessionRoundState(state, updatedAt) {
     const current = state.currentRound;
     if (!current) {
@@ -587,7 +623,9 @@ function normalizeRound(input) {
             : typeof legacy.pausedAt === "string"
                 ? legacy.pausedAt
                 : undefined,
-        stopReason: input.stopReason === "manual-interrupt" || input.stopReason === "runtime-recovery"
+        stopReason: input.stopReason === "manual-interrupt"
+            || input.stopReason === "runtime-recovery"
+            || input.stopReason === "terminal-exit"
             ? input.stopReason
             : undefined,
         activeTurnStartedAt: typeof input.activeTurnStartedAt === "string"

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

@@ -45,8 +45,6 @@ export function createRuntimeCoordinatorService(deps) {
                 return { activeTask: null, gatewayStatus };
             }
             const taskRepoRoot = getTaskRuntimeRepoRoot(activeTask);
-            const stateRoot = await deps.getStateRoot(repoRoot);
-            await deps.turnReconciler.reconcileTask(repoRoot, activeTask, stateRoot);
             const harnessInitialized = await deps.harnessService.getHarnessStatus(taskRepoRoot)
                 .then((status) => status.initialized)
                 .catch(() => false);

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

@@ -712,6 +712,44 @@ export function createSessionService(deps) {
         await persistRoleSessionRecord(deps.fs, repoRoot, getTaskRuntimeRepoRoot(task), config.stateRoot, updated);
         return updated;
     }
+    async function recordProjectToolProcessExit(repoRoot, current, input, persist) {
+        const timestamp = now();
+        const turnWasRunning = current.activityStatus === "running";
+        const updated = {
+            ...current,
+            status: input.status,
+            activityStatus: "idle",
+            pid: undefined,
+            exitCode: input.exitCode,
+            lastTurnEndedAt: turnWasRunning ? timestamp : current.lastTurnEndedAt,
+            updatedAt: timestamp
+        };
+        deps.registry.upsert(updated);
+        await persist(deps.fs, repoRoot, updated);
+        return { record: updated, turnWasRunning };
+    }
+    async function recordTaskRoleProcessExit(repoRoot, taskSlug, role, input) {
+        const current = await getTaskRoleSessionView(repoRoot, taskSlug, role);
+        if (!current || current.id !== input.sessionId) {
+            return undefined;
+        }
+        const timestamp = now();
+        const turnWasRunning = current.activityStatus === "running";
+        const updated = {
+            ...current,
+            status: input.status,
+            activityStatus: "idle",
+            pid: undefined,
+            exitCode: input.exitCode,
+            lastTurnEndedAt: turnWasRunning ? timestamp : current.lastTurnEndedAt,
+            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 { record: updated, turnWasRunning };
+    }
     return {
         async assertModelLaunchReady(model = "default") {
             await getModelLaunchEnvironment(normalizeClaudeModel(model));
@@ -1113,6 +1151,27 @@ export function createSessionService(deps) {
             }
             return markTaskRoleActivityIdle(repoRoot, taskSlug, role, sessionId);
         },
+        async recordTerminalProcessExit(repoRoot, input) {
+            const registered = deps.registry.get(input.sessionId);
+            const role = registered?.role;
+            const taskSlug = registered?.taskSlug;
+            if (!role || !taskSlug) {
+                return undefined;
+            }
+            if (role === TRANSLATOR_ROLE && taskSlug === PROJECT_TRANSLATOR_SCOPE) {
+                const current = await getProjectToolSessionView(repoRoot, TRANSLATOR_ROLE);
+                return current?.id === input.sessionId
+                    ? recordProjectToolProcessExit(repoRoot, current, input, persistTranslatorSession)
+                    : undefined;
+            }
+            if (role === HARNESS_ENGINEER_ROLE && taskSlug === PROJECT_HARNESS_ENGINEER_SCOPE) {
+                const current = await getProjectToolSessionView(repoRoot, HARNESS_ENGINEER_ROLE);
+                return current?.id === input.sessionId
+                    ? recordProjectToolProcessExit(repoRoot, current, input, persistHarnessEngineerSession)
+                    : undefined;
+            }
+            return recordTaskRoleProcessExit(repoRoot, taskSlug, role, input);
+        },
         async markRoleActivityRunning(repoRoot, taskSlug, role, expectedSessionId) {
             const current = await this.getRoleSession(repoRoot, taskSlug, role);
             if (!current || (expectedSessionId && current.id !== expectedSessionId)) {

package/dist/backend/services/terminal-process-exit-service.js

@@ -0,0 +1,43 @@
+import { isVcmRoleName } from "../../shared/constants.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+export function createTerminalProcessExitService(deps) {
+    let unsubscribe;
+    async function handleProcessExit(event) {
+        const repoRoot = event.session.repoRoot;
+        if (!repoRoot) {
+            return;
+        }
+        const recorded = await deps.sessionService.recordTerminalProcessExit(repoRoot, {
+            sessionId: event.session.id,
+            status: event.session.status === "crashed" ? "crashed" : "exited",
+            exitCode: event.exitCode
+        });
+        if (!recorded?.turnWasRunning || !isVcmRoleName(recorded.record.role)) {
+            return;
+        }
+        const config = await deps.projectService.loadConfig(repoRoot);
+        const task = await deps.taskService.loadTask(repoRoot, recorded.record.taskSlug);
+        await deps.roundService.recordTerminalExit({
+            repoRoot,
+            stateRepoRoot: getTaskRuntimeRepoRoot(task),
+            stateRoot: config.stateRoot,
+            taskSlug: recorded.record.taskSlug,
+            role: recorded.record.role
+        });
+    }
+    return {
+        start() {
+            if (unsubscribe) {
+                return;
+            }
+            unsubscribe = deps.runtime.subscribeProcessExits((event) => {
+                void handleProcessExit(event).catch(() => undefined);
+            });
+        },
+        stop() {
+            unsubscribe?.();
+            unsubscribe = undefined;
+        },
+        handleProcessExit
+    };
+}

package/package.json

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

package/dist/backend/services/turn-reconciler-service.js

@@ -1,59 +0,0 @@
-import { readTranscriptTurnEvidence } from "./claude-transcript-reply.js";
-import { getTaskRuntimeRepoRoot } from "./task-service.js";
-export function createTurnReconcilerService(deps) {
-    const readEvidence = deps.readTranscriptEvidence ?? readTranscriptTurnEvidence;
-    return {
-        async reconcileTask(repoRoot, task, stateRoot) {
-            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
-            const round = await deps.roundService.getSessionRoundState({
-                repoRoot,
-                stateRepoRoot: taskRepoRoot,
-                stateRoot,
-                taskSlug: task.taskSlug
-            });
-            if (round.status !== "running"
-                || !round.activeRole
-                || !round.activeTurnStartedAt
-                || round.roleRecovery) {
-                return { status: "inactive" };
-            }
-            const role = round.activeRole;
-            const session = await deps.sessionService.getRoleSession(repoRoot, task.taskSlug, role);
-            const evidence = session
-                ? await readEvidence({ ...session, lastTurnStartedAt: round.activeTurnStartedAt })
-                : {};
-            if (evidence.completion) {
-                await deps.claudeHookService.handleReconciledTurnEnd(buildReconciledHook(task.taskSlug, role, session, "Stop", {
-                    vcm_reconcile_reason: "transcript-end-turn",
-                    vcm_completion_id: evidence.completion.id,
-                    vcm_completion_at: evidence.completion.timestamp
-                }));
-                return { status: "completed", role, reason: "transcript-end-turn" };
-            }
-            if (!session || session.status !== "running") {
-                const reason = session ? "terminal-session-exited" : "terminal-session-missing";
-                await deps.claudeHookService.handleReconciledTurnEnd(buildReconciledHook(task.taskSlug, role, session, "StopFailure", {
-                    error: reason.replaceAll("-", "_"),
-                    error_details: `VCM reconciled an active turn because its ${reason.replaceAll("-", " ")}.`
-                }));
-                return { status: "failed", role, reason };
-            }
-            return { status: "active" };
-        }
-    };
-}
-function buildReconciledHook(taskSlug, role, session, eventName, evidence) {
-    return {
-        taskSlug,
-        role,
-        event: {
-            hook_event_name: eventName,
-            ...(session?.claudeSessionId ? { session_id: session.claudeSessionId } : {}),
-            ...(session?.transcriptPath ? { transcript_path: session.transcriptPath } : {}),
-            ...(session?.cwd ? { cwd: session.cwd } : {}),
-            ...(session?.id ? { vcm_runtime_session_id: session.id } : {}),
-            vcm_reconciled: true,
-            ...evidence
-        }
-    };
-}