vibe-coding-master 0.7.25 → 0.7.27

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();
     });
@@ -310,7 +312,8 @@ export function createDefaultServerDeps(options = {}) {
         taskService,
         appSettings,
         sessionService,
-        roundService
+        roundService,
+        onArchitecturePlanDisposition: ({ repoRoot, taskSlug, accepted }) => architectRestartService.recordArchitectureGateDisposition(repoRoot, taskSlug, accepted)
     });
     const translationWorkerService = createTranslationWorkerService({
         fs,
@@ -390,11 +393,6 @@ export function createDefaultServerDeps(options = {}) {
         translationWorkerService,
         architectRestartService
     });
-    const turnReconciler = createTurnReconcilerService({
-        sessionService,
-        roundService,
-        claudeHookService
-    });
     const runtimeCoordinator = createRuntimeCoordinatorService({
         appSettings,
         projectService,
@@ -406,7 +404,6 @@ export function createDefaultServerDeps(options = {}) {
         autoMemoryService,
         roundService,
         gatewayService,
-        turnReconciler,
         async getStateRoot(repoRoot) {
             return (await projectService.loadConfig(repoRoot)).stateRoot;
         }
@@ -418,6 +415,13 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         roundService
     });
+    const terminalProcessExitService = createTerminalProcessExitService({
+        runtime,
+        projectService,
+        taskService,
+        sessionService,
+        roundService
+    });
     const diagnosticsService = createDiagnosticsService({
         appRoot,
         runtime,
@@ -450,6 +454,7 @@ export function createDefaultServerDeps(options = {}) {
         runtimeCoordinator,
         runtimeRecoveryService,
         terminalInterruptService,
+        terminalProcessExitService,
         runtime,
         diagnosticsService,
         usageAnalyticsService

package/dist/backend/services/architect-restart-service.js

@@ -14,7 +14,7 @@ Before performing any assigned work, read:
 - the current scaffold commit and worktree state
 - the latest Gate Review report when present
 
-Treat the current artifacts and worktree as the source of truth. Do not repeat the completed interview or planning work unless current evidence contradicts them.`;
+Treat the current artifacts and worktree as the source of truth. The architecture-plan Gate has accepted the current planning artifacts or VCM recorded an explicit Gate exception. Do not repeat the completed interview or planning work unless a later route explicitly reopens it.`;
 export function createArchitectRestartService(deps) {
     const pendingByTask = new Map();
     return {
@@ -24,6 +24,11 @@ export function createArchitectRestartService(deps) {
             const key = taskKey(repoRoot, taskSlug);
             const existing = pendingByTask.get(key);
             if (existing?.sessionId === session.id) {
+                existing.stopped = false;
+                existing.deliveredMessageId = undefined;
+                existing.acceptedMessageId = undefined;
+                existing.gateAccepted = false;
+                existing.executing = false;
                 return { taskSlug, sessionId: session.id, status: "scheduled" };
             }
             pendingByTask.set(key, {
@@ -31,6 +36,7 @@ export function createArchitectRestartService(deps) {
                 taskSlug,
                 sessionId: session.id,
                 stopped: false,
+                gateAccepted: false,
                 executing: false
             });
             return { taskSlug, sessionId: session.id, status: "scheduled" };
@@ -65,6 +71,14 @@ export function createArchitectRestartService(deps) {
             pending.acceptedMessageId = message.id;
             await tryRestart(pending);
         },
+        async recordArchitectureGateDisposition(repoRoot, taskSlug, accepted) {
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending) {
+                return;
+            }
+            pending.gateAccepted = accepted;
+            await tryRestart(pending);
+        },
         clear(repoRoot, taskSlug) {
             pendingByTask.delete(taskKey(repoRoot, taskSlug));
         }
@@ -95,7 +109,8 @@ export function createArchitectRestartService(deps) {
         if (pending.executing
             || !pending.stopped
             || !pending.deliveredMessageId
-            || pending.deliveredMessageId !== pending.acceptedMessageId) {
+            || pending.deliveredMessageId !== pending.acceptedMessageId
+            || !pending.gateAccepted) {
             return;
         }
         const session = await deps.sessionService.getRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE);

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

@@ -121,6 +121,7 @@ export function createGateReviewService(deps) {
                 error: undefined
             }, now());
             await saveIndex(deps.fs, context.taskRepoRoot, index);
+            await notifyArchitecturePlanDisposition(context, gate, true);
             return { status: "disabled", gate, record: index.gates[gate], message: "Gate review is disabled." };
         }
         if (!record.required) {
@@ -130,6 +131,7 @@ export function createGateReviewService(deps) {
                 error: undefined
             }, now());
             await saveIndex(deps.fs, context.taskRepoRoot, index);
+            await notifyArchitecturePlanDisposition(context, gate, true);
             return { status: "not_required", gate, record: index.gates[gate], message: "This gate is not required." };
         }
         if (index.activeGate && index.activeGate !== gate) {
@@ -348,6 +350,7 @@ export function createGateReviewService(deps) {
             && record.status === "completed"
             && record.decision === "approve"
             && record.inputHash === inputHash) {
+            await notifyArchitecturePlanDisposition(context, gate, true);
             return {
                 status: "already_approved",
                 gate,
@@ -359,6 +362,7 @@ export function createGateReviewService(deps) {
         const requestId = createRequestId(gate);
         const requestPath = path.posix.join(REQUESTS_DIR, `${requestId}.json`);
         const promptPath = path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
+        const requestReportPath = reportPathForRequest(requestId);
         const nextRecord = {
             ...record,
             status: "running",
@@ -402,10 +406,12 @@ export function createGateReviewService(deps) {
             codeDiffSource,
             codeDiffSources,
             codeDiff: codeDiffInput,
-            reportPath: nextRecord.reportPath,
+            reportPath: requestReportPath,
+            latestReportPath: nextRecord.reportPath,
             promptPath: nextRecord.promptPath
         });
         await saveIndex(deps.fs, context.taskRepoRoot, index);
+        await notifyArchitecturePlanDisposition(context, gate, false);
         void runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources).catch(() => {
             // runGateReview records failures in the persisted gate state.
         });
@@ -456,11 +462,15 @@ export function createGateReviewService(deps) {
                 eventName: "UserPromptSubmit"
             });
             const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), reportPollIntervalMs);
+            await publishLatestGateReport(deps.fs, context.taskRepoRoot, gate, parsed.content);
             const completedAt = now();
             await updateRequestStatus(deps.fs, context, requestId, "completed", {
                 completedAt,
                 decision: parsed.decision,
-                reportPath: parsed.reportPath
+                summary: parsed.summary,
+                findings: parsed.findings,
+                reportPath: parsed.reportPath,
+                latestReportPath: reportPathForGate(gate)
             });
             activeRuns.delete(runKey);
             await updateGateRecord(context, gate, {
@@ -474,6 +484,7 @@ export function createGateReviewService(deps) {
                 callbackError: undefined,
                 updatedAt: completedAt
             }, { clearActiveGate: true });
+            await notifyArchitecturePlanDisposition(context, gate, parsed.decision === "approve");
             await callbackProjectManager(context, gate, "completed", parsed.decision, parsed.reportPath);
         }
         catch (error) {
@@ -492,7 +503,8 @@ export function createGateReviewService(deps) {
                 callbackError: undefined,
                 updatedAt: timestamp
             }, { clearActiveGate: true });
-            await callbackProjectManager(context, gate, "failed", undefined, reportPathForGate(gate), message);
+            await notifyArchitecturePlanDisposition(context, gate, false);
+            await callbackProjectManager(context, gate, "failed", undefined, reportPathForRequest(requestId), message);
         }
         finally {
             activeRuns.delete(runKey);
@@ -570,6 +582,21 @@ export function createGateReviewService(deps) {
             });
         }
     }
+    async function notifyArchitecturePlanDisposition(context, gate, accepted) {
+        if (gate !== "architecture-plan" || !deps.onArchitecturePlanDisposition) {
+            return;
+        }
+        try {
+            await deps.onArchitecturePlanDisposition({
+                repoRoot: context.repoRoot,
+                taskSlug: context.taskSlug,
+                accepted
+            });
+        }
+        catch {
+            // Gate state remains authoritative even if the deferred session restart cannot run yet.
+        }
+    }
     return {
         async getState(repoRoot, taskSlug) {
             const context = await getContext(repoRoot, taskSlug);
@@ -628,6 +655,7 @@ export function createGateReviewService(deps) {
                 callbackError: undefined,
                 updatedAt: now()
             }, { clearActiveGate: true });
+            await notifyArchitecturePlanDisposition(context, gate, true);
             await callbackProjectManager(context, gate, "skipped", undefined, index.gates[gate].reportPath);
             return loadIndex(deps.fs, context, now());
         },
@@ -653,12 +681,13 @@ export function createGateReviewService(deps) {
                 callbackError: undefined,
                 updatedAt: now()
             }, { clearActiveGate: true });
+            await notifyArchitecturePlanDisposition(context, gate, true);
             await callbackProjectManager(context, gate, "overridden", "approve", index.gates[gate].reportPath);
             return loadIndex(deps.fs, context, now());
         },
         async readReport(repoRoot, taskSlug, gate) {
             const context = await getContext(repoRoot, taskSlug);
-            return parseGateReport(deps.fs, context.taskRepoRoot, gate, undefined, now());
+            return parseGateReport(deps.fs, context.taskRepoRoot, gate, undefined, now(), reportPathForGate(gate));
         }
     };
 }
@@ -1036,7 +1065,7 @@ function splitLines(value) {
         .filter(Boolean);
 }
 function buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources) {
-    const reportPath = reportPathForGate(gate);
+    const reportPath = reportPathForRequest(requestId);
     const absoluteReportPath = resolveRepoPath(context.taskRepoRoot, reportPath);
     const evidence = getSourceArtifacts(gate, codeDiffSources)
         .map((relativePath) => `- ${relativePath}`)
@@ -1089,9 +1118,10 @@ Summary: <one or two sentences>
 [/VCM GATE REVIEW]`;
 }
 async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, intervalMs) {
+    const reportPath = reportPathForRequest(requestId);
     while (true) {
         try {
-            return await parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp);
+            return await parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp, reportPath);
         }
         catch (error) {
             if (!isPendingReportError(error)) {
@@ -1101,8 +1131,7 @@ async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, i
         await delay(intervalMs);
     }
 }
-async function parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp) {
-    const reportPath = reportPathForGate(gate);
+async function parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp, reportPath) {
     const absolutePath = resolveRepoPath(taskRepoRoot, reportPath);
     if (!(await fs.pathExists(absolutePath))) {
         throw new VcmError({
@@ -1296,9 +1325,20 @@ async function updateRequestStatus(fs, context, requestId, status, patch) {
         updatedAt: new Date().toISOString()
     });
 }
+async function publishLatestGateReport(fs, taskRepoRoot, gate, content) {
+    const latestPath = resolveRepoPath(taskRepoRoot, reportPathForGate(gate));
+    if (fs.writeTextAtomic) {
+        await fs.writeTextAtomic(latestPath, content);
+        return;
+    }
+    await fs.writeText(latestPath, content);
+}
 function reportPathForGate(gate) {
     return path.posix.join(GATE_REVIEW_DIR, `${gate}-review.md`);
 }
+function reportPathForRequest(requestId) {
+    return path.posix.join(REQUESTS_DIR, `${requestId}.report.md`);
+}
 function promptPathForRequest(requestId) {
     return path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
 }

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/dist/backend/templates/handoff.js

@@ -143,7 +143,7 @@ At task close, promote still-relevant confirmed issues to \`docs/known-issues.md
 export function renderTestReportTemplate(taskSlug) {
     return `# Test Report: ${taskSlug}
 
-Test Result: pass|fail
+Test Result: pass|fail|incomplete
 
 ## Evidence Reviewed
 
@@ -157,6 +157,16 @@ TBD
 
 TBD
 
+## Validation Progress
+
+### Completed Validation
+
+TBD
+
+### Remaining Validation
+
+TBD
+
 ## L3 Coverage
 
 L3 Required: yes|no

package/dist/backend/templates/harness/architect-agent.js

@@ -116,7 +116,7 @@ ${renderRoleMemoryRules("architect")}
 #### Planning Completion
 
 - After the complete plan, scaffold, reconciliation, L0 evidence, and commits are ready, use the \`restart-architect\` skill before writing the completed Architect-to-PM route message.
-- After VCM reports the restart is scheduled, write the route message with both architecture artifacts and the plan, then end the turn. Do not wait for or inspect the replacement session.
+- After VCM reports the restart is scheduled, write the route message with both architecture artifacts and the plan, then end the turn. VCM keeps this session for any architecture-plan Gate revision and restarts it only after the Gate is accepted. Do not wait for or inspect the replacement session.
 
 ### Complete Task Planning
 

package/dist/backend/templates/harness/gate-review.js

@@ -135,6 +135,10 @@ when the active flow produced an architecture plan. Read
 When the report contains an approved Coverage Gap, also read the relevant
 Architect Debug and Architecture Diagnosis evidence.
 
+Validation-adequacy reviews only a terminal \`Test Result: pass|fail\`.
+\`Test Result: incomplete\` is Tester continuation state and must not enter this
+gate.
+
 Reconstruct the accepted validation target, observable behavior, and risks
 from the active flow evidence and current implementation. Treat Tester
 conclusions, green commands, and
@@ -460,7 +464,7 @@ Use this skill at every project-manager Gate Review trigger point and whenever V
 ## Trigger Points
 
 - \`architecture-plan\`: after the user confirms \`.ai/vcm/handoffs/architecture-brief.md\` and architect writes \`.ai/vcm/handoffs/architecture-plan.md\`, before coder dispatch.
-- \`validation-adequacy\`: after tester writes \`.ai/vcm/handoffs/test-report.md\`, before post-validation docs sync or final acceptance in a code-delivery flow, or before Validation-Only Flow completion.
+- \`validation-adequacy\`: after tester writes a terminal \`Test Result: pass|fail\` that the active flow permits to reach the gate, before post-validation docs sync or final acceptance in a code-delivery flow, or before Validation-Only Flow completion. Never request this gate for \`Test Result: incomplete\`.
 - \`code-diff\`: after Coder returns \`Decision: ready_for_review\`, Architect Debug Mode completes a code fix, or Architecture Diagnosis Mode completes a code fix, before PM routes to Tester. Identify the source with \`--source coder\`, \`--source architect-debug\`, or \`--source architect-diagnosis\`.
 
 ## Request
@@ -508,7 +512,7 @@ from pathlib import Path
 
 GATES = ("architecture-plan", "validation-adequacy", "code-diff")
 CODE_DIFF_SOURCES = ("coder", "architect-debug", "architect-diagnosis")
-REPORTS = {
+LATEST_REPORTS = {
     "architecture-plan": ".ai/vcm/gate-reviews/architecture-plan-review.md",
     "validation-adequacy": ".ai/vcm/gate-reviews/validation-adequacy-review.md",
     "code-diff": ".ai/vcm/gate-reviews/code-diff-review.md",
@@ -931,13 +935,14 @@ def local_request(gate: str, source: str | None) -> int:
         and gate_record.get("decision") == "approve"
         and gate_record.get("inputHash") == current_hash
     ):
-        print_result("already_approved", gate=gate, report=gate_record.get("reportPath", REPORTS[gate]))
+        print_result("already_approved", gate=gate, report=gate_record.get("reportPath", LATEST_REPORTS[gate]))
         return 0
 
     rid = request_id(gate)
     request_path = root / ".ai/vcm/gate-reviews/requests" / f"{rid}.json"
     prompt_path = f".ai/vcm/gate-reviews/requests/{rid}.prompt.md"
-    report_path = REPORTS[gate]
+    report_path = f".ai/vcm/gate-reviews/requests/{rid}.report.md"
+    latest_report_path = LATEST_REPORTS[gate]
     requested_at = now_iso()
     write_json(request_path, {
         "version": 1,
@@ -950,6 +955,7 @@ def local_request(gate: str, source: str | None) -> int:
         "codeDiffSources": sources,
         "codeDiff": code_diff or None,
         "reportPath": report_path,
+        "latestReportPath": latest_report_path,
         "promptPath": prompt_path,
     })
 
@@ -959,7 +965,7 @@ def local_request(gate: str, source: str | None) -> int:
         "required": True,
         "status": "running",
         "decision": None,
-        "reportPath": report_path,
+        "reportPath": latest_report_path,
         "promptPath": prompt_path,
         "inputHash": current_hash,
         "baseCommit": code_diff.get("baseCommit"),

package/dist/backend/templates/harness/project-manager-agent.js

@@ -93,6 +93,7 @@ PM may leave this path only through the allowed branches below.
 - **Coder Continuation:** If Coder returns \`Decision: incomplete\`, lacks the required completion artifact, or has not completed implementation and L0/L1 validation, route Coder again — this is the only route for an in-progress sweep. Problems recorded inside an incomplete report are sweep state, not routable failures; PM routes problems onward only from a post-sweep \`failed\` report carrying the consolidated per-item disposition.
 - **Coder Failure Debug:** If Coder returns \`Decision: failed\` with compile, typecheck, or L0/L1 failure evidence after implementation, suspend the main flow and enter Architect Debug Branch.
 - **Code-Diff Correction:** If the code-diff Gate returns \`request_changes\`, suspend the main flow and enter Architect Debug Branch with the Gate report.
+- **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation. Do not enter Debug, Diagnosis, or validation-adequacy Gate Review.
 - **Tester Failure:** If Tester returns \`Test Result: fail\` for the original Coder implementation, enter Architect Debug Branch.
 - **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the report to Tester, then rerun the validation-adequacy Gate after Tester updates the tests or test report.
 - **Docs Sync Correction:** \`Decision: synced\` or \`unchanged\` continues to Final Acceptance. \`Decision: blocked\` remains at docs sync unless the report identifies an allowed Debug, Diagnosis, or user-decision branch.
@@ -151,6 +152,7 @@ The shared path is:
 
 - **Normal Plan Required:** If Architect returns \`normal architecture plan required\`, enter Code-Change Flow at Architect planning. When Debug is a branch of Code-Change Flow, resume that parent flow at Architect planning.
 - **Code-Diff Revision:** If the code-diff Gate returns \`request_changes\`, route the report to Architect Debug Mode and rerun \`code-diff --source architect-debug\` after correction.
+- **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation.
 - **Architecture Diagnosis:** If Tester returns \`Test Result: fail\`, enter Architecture Diagnosis Branch.
 
 #### Successful Exit
@@ -180,6 +182,7 @@ Architecture Diagnosis Mode must run before another Debug Mode fix or Coder disp
 #### Allowed Branches
 
 - **Code-Diff Revision:** If the code-diff Gate returns \`request_changes\`, route the report to Architecture Diagnosis Mode and rerun \`code-diff --source architect-diagnosis\` after correction.
+- **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation.
 - **Tester Failure:** If Tester returns \`Test Result: fail\` for the Diagnosis implementation, pause and report to the user. If required validation remains unavailable, ask whether the user explicitly approves retaining that exact Coverage Gap.
 
 #### Successful Exit
@@ -242,7 +245,7 @@ The flow is:
 
 \`Tester validation and test update -> validation-adequacy Gate -> PM completion\`
 
-Tester must complete the accepted validation work, write \`.ai/vcm/handoffs/test-report.md\`, and return \`Test Result: pass|fail\`.
+Tester must write \`.ai/vcm/handoffs/test-report.md\` and return \`Test Result: pass|fail|incomplete\`.
 
 If Tester changes tests, fixtures, test-only helpers, or \`docs/TESTING.md\`, Tester must commit those changes and record the changed files and commit in \`test-report.md\`.
 
@@ -252,7 +255,7 @@ PM may leave this path only through the allowed branches below.
 
 #### Allowed Branches
 
-- **Tester Continuation:** If the assigned validation work or test report is incomplete, route Tester again.
+- **Tester Continuation:** If Tester returns \`Test Result: incomplete\`, route Tester again to continue the recorded remaining validation.
 - **Validation Revision:** If the validation-adequacy Gate returns \`request_changes\`, route the report to Tester and rerun the Gate after correction.
 - **Code Change Required:** If the accepted outcome requires production-code, runtime-behavior, public-contract, dependency, or system-architecture changes, enter Code-Change Flow at Architect planning.
 - **User Decision:** If validation requires missing user intent, credentials, environment access, sensitive data, real cost, or external authorization, pause and ask the user.
@@ -321,6 +324,7 @@ PM may lightly rewrite the user's words to:
 - In an Architect Debug Branch or Architecture Diagnosis Branch, track the parent flow, resume point, Architect result, test report, and required Gate Review results. Do not require a branch-level final acceptance report.
 - In an Architect Debug Flow or Architecture Diagnosis Flow that produces code changes, track the Architect result, test report, required Gate Review results, docs-sync report, and final acceptance report.
 - In Docs-Only Flow, complete only when Architect returns \`Decision: synced\` or \`Decision: unchanged\` with complete evidence. In Validation-Only Flow, complete only from a complete \`test-report.md\` after the validation-adequacy Gate finishes successfully.
+- A Tester \`Test Result: incomplete\` is continuation state, not failure evidence. Route Tester again and do not run validation-adequacy Gate Review or Final Acceptance from it.
 - The Architect does not begin planning until \`architecture-brief.md\` is confirmed (this happens inside the same Architect Interview-and-planning turn, not a separate PM route). Advance to the next gate only when the required role artifact/result is complete and PM routing rules allow that gate.
 - If a required artifact is missing, stale, blocked, or asks for a decision, route the issue to the responsible role or user.
 - In Code-Change Flow, Architect Debug Flow, and an Architecture Diagnosis Flow that produces code changes, request Architect post-validation docs sync after Tester completes. Architect Debug Branch and Architecture Diagnosis Branch return to their recorded resume points after Tester passes.
@@ -329,7 +333,7 @@ PM may lightly rewrite the user's words to:
 
 - Gate Review requests are mandatory and unconditional. At every trigger point, use the \`vcm-gate-review\` skill to run \`.ai/tools/request-gate-review\` with the matching gate and code source arguments without first judging whether Gate Review is enabled. The tool (via VCM) is the single source of truth for enable state; never skip the run because you assume Gate Review is off or because the worktree has no gate-review index yet.
 - The tool's first output line decides the next step: \`disabled\`, \`not_required\`, or \`already_approved\` continue the normal VCM flow; \`started\` or \`running\` stop the turn and wait for the VCM callback; \`failed_to_start\` is a hard stop — report it to the user and do not silently proceed past the gate.
-- Trigger points (run each unconditionally): after the architecture brief is confirmed and Architect completes planning, before coder dispatch run \`architecture-plan\`; before post-validation docs sync or final acceptance in a code-delivery flow, or before Validation-Only Flow completion, run \`validation-adequacy\`; after any Coder \`Decision: ready_for_review\` result run \`code-diff --source coder\`; after any Architect Debug Mode completed code fix run \`code-diff --source architect-debug\`; after any Architecture Diagnosis Mode completed code fix run \`code-diff --source architect-diagnosis\`. Run code-diff before routing to Tester.
+- Trigger points (run each unconditionally): after the architecture brief is confirmed and Architect completes planning, before coder dispatch run \`architecture-plan\`; after Tester returns a terminal \`Test Result: pass|fail\` that the active flow permits to reach the gate, before post-validation docs sync or final acceptance in a code-delivery flow, or before Validation-Only Flow completion, run \`validation-adequacy\`; after any Coder \`Decision: ready_for_review\` result run \`code-diff --source coder\`; after any Architect Debug Mode completed code fix run \`code-diff --source architect-debug\`; after any Architecture Diagnosis Mode completed code fix run \`code-diff --source architect-diagnosis\`. Never run validation-adequacy for \`Test Result: incomplete\`. Run code-diff before routing to Tester.
 - PM does not inspect commits or decide whether code changes exist. At a \`code-diff\` trigger point, run the tool; the tool decides \`disabled\`, \`not_required\`, \`already_approved\`, or starts review.
 - Do not run \`code-diff\` for incomplete, failed, planning-only, Docs-Only Flow, Validation-Only Flow, PR-Preparation Flow, or Communication-Only Flow.
 - Gate Review trigger points apply only when the active delivery flow reaches that milestone. Do not run Gate Review for Communication-Only Flow.

package/dist/backend/templates/harness/restart-architect-skill.js

@@ -9,7 +9,7 @@ Run:
 .ai/tools/request-architect-restart
 \`\`\`
 
-If VCM reports \`scheduled\`, write the completed Architect-to-PM route message and end the turn. VCM restarts Architect only after the route is accepted by PM.
+If VCM reports \`scheduled\`, write the completed Architect-to-PM route message and end the turn. VCM keeps the current Architect session through any architecture-plan Gate revision rounds and restarts it only after the route is accepted by PM and that Gate is approved or explicitly excepted.
 
 Do not use this skill for incomplete planning, user clarification, Debug Mode, Architecture Diagnosis Mode, or docs sync.`;
 }

package/dist/backend/templates/harness/tester-agent.js

@@ -26,7 +26,7 @@ ${renderRoleMemoryRules("tester")}
 - Do not treat "looks normal", "no error", log absence, or implementation reasoning as validation evidence.
 - Coder may write and run L0/L1 baseline tests during implementation, but Tester owns final test adequacy for all validation levels.
 - Review Coder-provided L0/L1 evidence and changed unit tests against \`docs/CODING_STANDARDS.md\`; confirm changed callable units have required success, failure, boundary, validation, branching, error-handling, lifecycle, retry, or state-transition coverage.
-- If required L0/L1 coverage is missing or weak, add or update the required tests. If the coverage cannot be completed, return \`Test Result: fail\` with concrete blocking evidence.
+- If required L0/L1 coverage is missing or weak, add or update the required tests. If the current turn ends while that work can continue in another Tester turn and no blocking issue has been found, return \`Test Result: incomplete\` with completed and remaining validation. If Tester continuation cannot resolve the missing coverage, return \`Test Result: fail\` with concrete blocking evidence.
 - Own L2/L3/L4 final-validation design, execution, and acceptance evidence.
 - Targeted diagnostic L2 checks run by Coder or Architect are implementation evidence only and do not replace Tester final validation.
 - Use L2 integration coverage when changed behavior crosses internal module or component boundaries and can be completely proved from a stable integration entry point without triggering the mandatory L3 rules below.
@@ -53,7 +53,8 @@ ${renderRoleMemoryRules("tester")}
 - Before exact user approval is routed by project-manager, record missing required coverage under \`Blocking Validation Issues\`, keep \`Coverage Gaps\` as \`None\`, and return \`Test Result: fail\`.
 - Add a Coverage Gap only after project-manager routes the user's exact approval for that specific unresolved gap. Record the approval verbatim in \`User Approval Evidence\`.
 - User approval permits the gap to remain and the workflow to continue; it does not change the factual \`Test Result: fail\`.
-- If a required validation check is skipped or cannot complete, \`Test Result\` must be \`fail\`.
+- If the current turn ends before required validation finishes, use \`Test Result: incomplete\` only when no blocking issue has been found and Tester can continue the remaining checks in another turn.
+- A required check that fails, is skipped, or cannot be completed by Tester continuation is a blocking validation issue and requires \`Test Result: fail\`.
 - Update \`docs/TESTING.md\` when validation strategy, commands, level mapping, integration/E2E case definitions, selection rules, final-validation cleanup, test gaps, or test expectations change.
 
 ### Mandatory L3 End-To-End Coverage
@@ -125,7 +126,7 @@ Coverage Gap.
 
 ### Outputs
 
-- Write \`.ai/vcm/handoffs/test-report.md\` with \`Test Result: pass|fail\`, evidence reviewed, tests added or updated, coverage mapping, commands run or checked, validation results, failed expectations, reproduction steps, skipped checks with reasons, coverage gaps, blocking validation issues, and user approval evidence.
+- Write \`.ai/vcm/handoffs/test-report.md\` with \`Test Result: pass|fail|incomplete\`, evidence reviewed, tests added or updated, coverage mapping, validation progress, commands run or checked, validation results, failed expectations, reproduction steps, skipped checks with reasons, coverage gaps, blocking validation issues, and user approval evidence.
 - \`test-report.md\` must include this L3 section:
 
 \`\`\`md
@@ -150,9 +151,12 @@ L3 Required: yes|no
 - In Validation-Only Flow, if tests, fixtures, test-only helpers, or \`docs/TESTING.md\` changed, commit those changes before reporting and record the changed files and commit in \`test-report.md\`. If no tracked files changed, record that no commit was required.
 - \`test-report.md\` is the current validation evidence, not a log; when rewriting it, carry forward still-unresolved findings or explicitly mark them resolved instead of dropping them.
 - In \`Coverage Mapping\`, map each accepted changed behavior or relevant risk to its validation level, actual test file and case or external evidence, exercised entry path and key assertions, result, and any remaining gap.
+- In \`Validation Progress\`, record \`Completed Validation\` and \`Remaining Validation\`. A final \`pass\` report must set remaining validation to \`None\`.
 - Use \`pass\` only when required validation completed and no blocking test failure, missing required coverage, unacceptable test weakness, or unresolved validation risk remains.
-- Use \`fail\` when tests fail, coverage is insufficient, important validation cannot complete, test quality is unacceptable, or validation risk needs project-manager routing.
-- When \`Test Result: pass\`, \`Coverage Gaps\`, \`Blocking Validation Issues\`, and \`User Approval Evidence\` must be \`None\`.
+- Use \`fail\` only when tests fail, coverage is insufficient and Tester continuation cannot resolve it, required validation is blocked from completion, test quality is unacceptable, or validation risk needs project-manager routing.
+- Use \`incomplete\` only when required validation remains, no blocking issue has been found, and another Tester turn can continue the recorded remaining work.
+- When \`Test Result: pass\`, \`Failed Expectations\`, \`Coverage Gaps\`, \`Blocking Validation Issues\`, and \`User Approval Evidence\` must be \`None\`.
+- When \`Test Result: incomplete\`, \`Completed Validation\` and \`Remaining Validation\` must both contain concrete progress, while \`Failed Expectations\`, \`Coverage Gaps\`, \`Blocking Validation Issues\`, and \`User Approval Evidence\` must be \`None\`.
 - When \`Test Result: fail\`, \`Blocking Validation Issues\` must list concrete blocking evidence.
 - When \`Coverage Gaps\` is not \`None\`, \`Test Result\` must be \`fail\`, \`User Approval Evidence\` must contain the user's exact authorization, and every recorded gap must match that authorization.
 - When no gap has been approved, \`User Approval Evidence\` must be \`None\`.

package/dist/backend/templates/harness/vcm-final-acceptance-skill.js

@@ -30,7 +30,7 @@ Check whether the required role evidence exists, is current, and gives a clear r
 Acceptable evidence must show:
 
 - architect plan, architecture diagnosis, or docs-sync decision when required by the completed flow
-- tester \`Test Result: pass|fail\` and validation evidence when code, behavior, tests, or generated context changed
+- tester terminal \`Test Result: pass|fail\` and validation evidence when code, behavior, tests, or generated context changed; \`incomplete\` is not acceptance evidence
 - required Gate Review decisions, skip reasons, or override reasons when Gate Reviews were enabled
 - known-issues disposition when unresolved findings were recorded
 - explicit user approval for accepted high-risk decisions or intentionally skipped required gates
@@ -58,7 +58,7 @@ Check:
 - required route was followed, or an explicit user-approved exception is recorded
 - required handoff artifacts exist and are current
 - architecture plan, Architecture Diagnosis, Replan, or architect follow-up completion is recorded when required by the flow
-- tester report records \`Test Result: pass|fail\`, validation commands, results, and skipped checks with reasons
+- tester report records terminal \`Test Result: pass|fail\`, validation commands, results, and skipped checks with reasons; do not accept \`Test Result: incomplete\`
 - required Gate Reviews are approved, or skipped/overridden through a VCM-recorded user action
 - Gate Review enable state is confirmed authoritatively: do not infer that no Gate Reviews were required from an absent or empty \`.ai/vcm/gate-reviews/index.json\`. When Gate Review is enabled, a missing index or a required gate without a recorded decision means the gate was skipped — run the matching command from the \`vcm-gate-review\` skill, including the code source for \`code-diff\`, and do not accept until each required gate returns \`approve\`/\`already_approved\`, \`disabled\`/\`not_required\`, or a VCM-recorded user skip/override
 - docs-sync report records docs updated, docs intentionally left unchanged, or required follow-up when docs sync was required

package/dist/shared/validation/artifact-check.js

@@ -39,6 +39,9 @@ const REQUIRED_HEADINGS = {
         "Evidence Reviewed",
         "Tests Added Or Updated",
         "Coverage Mapping",
+        "Validation Progress",
+        "Completed Validation",
+        "Remaining Validation",
         "L3 Coverage",
         "Trigger Assessment",
         "Affected End-To-End Flows",
@@ -105,6 +108,8 @@ export function checkMarkdownArtifact(kind, artifactPath, content) {
     const missingHeadings = REQUIRED_HEADINGS[kind].filter((heading) => !hasHeading(trimmed, heading));
     const hasPlaceholder = PLACEHOLDER_PATTERN.test(trimmed);
     const invalidFields = validateArtifactFields(kind, trimmed);
+    const isWorkInProgress = kind === "test-report"
+        && /^\s*Test Result\s*:\s*incomplete\s*$/im.test(trimmed);
     return {
         kind,
         path: artifactPath,
@@ -113,7 +118,12 @@ export function checkMarkdownArtifact(kind, artifactPath, content) {
         hasPlaceholder,
         missingHeadings,
         invalidFields,
-        status: missingHeadings.length === 0 && !hasPlaceholder && invalidFields.length === 0 ? "ok" : "incomplete"
+        status: missingHeadings.length === 0
+            && !hasPlaceholder
+            && invalidFields.length === 0
+            && !isWorkInProgress
+            ? "ok"
+            : "incomplete"
     };
 }
 function validateArtifactFields(kind, content) {
@@ -141,9 +151,9 @@ function validateArtifactFields(kind, content) {
     }
     if (kind === "test-report") {
         const result = /^\s*Test Result\s*:\s*(\S+)\s*$/im.exec(content)?.[1]?.toLowerCase();
-        const invalidFields = result === "pass" || result === "fail"
+        const invalidFields = result === "pass" || result === "fail" || result === "incomplete"
             ? []
-            : ["Test Result must be pass or fail."];
+            : ["Test Result must be pass, fail, or incomplete."];
         const l3Required = /^\s*L3 Required\s*:\s*(\S+)\s*$/im.exec(content)?.[1]?.toLowerCase();
         if (l3Required !== "yes" && l3Required !== "no") {
             invalidFields.push("L3 Required must be yes or no.");
@@ -169,9 +179,13 @@ function validateArtifactFields(kind, content) {
         const coverageGaps = readArtifactSectionValue(content, "Coverage Gaps");
         const blockingIssues = readArtifactSectionValue(content, "Blocking Validation Issues");
         const userApproval = readArtifactSectionValue(content, "User Approval Evidence");
+        const failedExpectations = readArtifactSectionValue(content, "Failed Expectations");
+        const completedValidation = readArtifactSectionValue(content, "Completed Validation");
+        const remainingValidation = readArtifactSectionValue(content, "Remaining Validation");
         const hasCoverageGaps = Boolean(coverageGaps && !/^none\.?$/i.test(coverageGaps));
         const hasBlockingIssues = Boolean(blockingIssues && !/^none\.?$/i.test(blockingIssues));
         const hasUserApproval = Boolean(userApproval && !/^none\.?$/i.test(userApproval));
+        const hasFailedExpectations = Boolean(failedExpectations && !/^none\.?$/i.test(failedExpectations));
         if (result === "pass") {
             if (!coverageGaps || hasCoverageGaps) {
                 invalidFields.push("Coverage Gaps must be None when Test Result is pass.");
@@ -182,6 +196,32 @@ function validateArtifactFields(kind, content) {
             if (!userApproval || hasUserApproval) {
                 invalidFields.push("User Approval Evidence must be None when Test Result is pass.");
             }
+            if (!failedExpectations || hasFailedExpectations) {
+                invalidFields.push("Failed Expectations must be None when Test Result is pass.");
+            }
+            if (hasSubstantiveSectionValue(remainingValidation)) {
+                invalidFields.push("Remaining Validation must be None when Test Result is pass.");
+            }
+        }
+        if (result === "incomplete") {
+            if (!hasSubstantiveSectionValue(completedValidation)) {
+                invalidFields.push("Completed Validation must record progress when Test Result is incomplete.");
+            }
+            if (!hasSubstantiveSectionValue(remainingValidation)) {
+                invalidFields.push("Remaining Validation must list continuation work when Test Result is incomplete.");
+            }
+            if (hasCoverageGaps) {
+                invalidFields.push("Coverage Gaps must be None when Test Result is incomplete.");
+            }
+            if (hasBlockingIssues) {
+                invalidFields.push("Blocking Validation Issues must be None when Test Result is incomplete.");
+            }
+            if (hasUserApproval) {
+                invalidFields.push("User Approval Evidence must be None when Test Result is incomplete.");
+            }
+            if (hasFailedExpectations) {
+                invalidFields.push("Failed Expectations must be None when Test Result is incomplete.");
+            }
         }
         if (result === "fail" && !hasBlockingIssues) {
             invalidFields.push("Blocking Validation Issues must contain concrete evidence when Test Result is fail.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.7.25",
+  "version": "0.7.27",
   "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
-        }
-    };
-}