poly-weaver 0.15.2 → 1.0.0

package/dist/crosscheck/coordinator.js

@@ -4,7 +4,7 @@ import { bold, dim, MUTED_YELLOW_BG, padOrClip, reset, TRUE_BLACK_FG, } from "..
 import { APP_VERSION } from "../version.js";
 import { buildExecutorInitialPrompt, buildExecutorCrosscheckPrompt, buildExecutorEffectiveTaskContext, buildExecutorFollowUpPrompt, buildExecutorReconcilePrompt, buildExecutorSteerFreshPrompt, buildExecutorSteerPrompt, } from "../agents/executors/prompts.js";
 import { sendInquiryQuestion } from "../offscreen/inquiry-sender.js";
-import { SessionTurnMonitor } from "../offscreen/session-turn-monitor.js";
+import { SessionTurnMonitor, SessionTurnReceipt } from "../offscreen/session-turn-monitor.js";
 import { resolveProvider } from "../providers/registry.js";
 import { compactProviderConfigurationTokens, } from "../providers/configuration-presentation.js";
 import { readSessionFileWithStatus } from "../session/reader.js";
@@ -87,6 +87,7 @@ export class CrosscheckCoordinator {
     resultRefresh;
     launchAbort;
     sessionsReady = false;
+    launchReconciliationPending = false;
     transientFlash;
     crosscheckProgress;
     selectionAgent;
@@ -110,7 +111,10 @@ export class CrosscheckCoordinator {
             const layout = this.options.host.getLayout();
             const dimensions = this.paneDimensions(layout.columns, layout.childRows);
             await this.reconcilePersistedHistory();
+            if (this.finishing)
+                return { kind: "crosscheck", interrupted: true };
             const persisted = this.store.snapshot();
+            this.launchReconciliationPending = true;
             const launchAbort = new AbortController();
             this.launchAbort = launchAbort;
             const completion = new Promise((resolve, reject) => {
@@ -119,11 +123,12 @@ export class CrosscheckCoordinator {
                 if (this.pendingFailure !== undefined)
                     reject(this.pendingFailure);
             });
+            completion.catch(() => { });
             let hasLaunchFailure = false;
             let firstLaunchFailure;
             const launches = ["agent-1", "agent-2"].map(async (agent) => {
+                const config = this.options.configurations[agent];
                 try {
-                    const config = this.options.configurations[agent];
                     const resultFile = persisted.generation.resultFiles[agent];
                     const resultState = persisted.generation.rewind?.[agent];
                     const resultReady = resultState ? false : await fileHasContent(resultFile);
@@ -160,7 +165,9 @@ export class CrosscheckCoordinator {
                                 : activityState === "working"
                                     ? RESUME_CONTINUE_PROMPT
                                     : resumePrompt;
+                    const launchTurnReceipt = new SessionTurnReceipt();
                     const session = await (this.options.launchSession ?? LiveAgentSession.launch)({
+                        launchTurnReceipt,
                         driver: config.driver,
                         workdir: this.options.workdir,
                         prompt,
@@ -176,6 +183,7 @@ export class CrosscheckCoordinator {
                         cols: dimensions[agent].cols,
                         rows: dimensions[agent].rows,
                         sessionFileWaitMs: this.options.sessionFileWaitMs,
+                        observerRun: this.options.providerObserverRuns?.get(config.driver),
                         onRender: () => this.options.host.scheduleParentUiRender(),
                         onOscClipboard: (data) => this.options.host.forwardOscClipboard(data),
                         onSpawn: (session) => {
@@ -187,28 +195,11 @@ export class CrosscheckCoordinator {
                                 this.fail(new Error(`${config.driver} ${agentLabel(agent)} exited unexpectedly (code ${event.exitCode})`));
                             }
                         },
-                    });
-                    this.launchingSessions.delete(agent);
-                    const monitor = new SessionTurnMonitor(config.driver, session.identity.sessionFilePath, session.baseline, {
-                        initialHistorySnapshot: persisted.sessions[agent]?.historySnapshot,
-                        onHistorySnapshot: (snapshot) => {
-                            void this.store.updateSessionHistory(agent, snapshot);
-                        },
-                        onHistoryRegression: (_regression, snapshot) => {
-                            this.runDispatchOperation(agent, this.invalidateGenerationForRewind(agent, snapshot), "invalidate rewound generation");
-                        },
-                        onChange: (idle) => {
-                            this.refreshStatusHint();
-                            this.options.host.scheduleParentUiRender();
-                            if (idle) {
-                                const progressIdentity = this.takeCrosscheckTurnIdentity(agent);
-                                this.runDispatchOperation(agent, this.handleAgentIdle(agent, progressIdentity), "prepare resumed crosscheck");
-                            }
-                        },
-                        onReadFailure: () => {
-                            this.options.output.warn(`${config.driver} ${agentLabel(agent)} session log is unreadable; crosscheck remains disarmed`);
+                        onObserverError: (error) => {
+                            this.fail(observerFailureError(config.driver, agent, error));
                         },
                     });
+                    this.launchingSessions.set(agent, session);
                     const persistedDispatch = persisted.generation.dispatch;
                     const freshForPendingDispatch = persistedDispatch !== undefined
                         && (persistedDispatch.phase === "crosscheck"
@@ -216,23 +207,14 @@ export class CrosscheckCoordinator {
                             : true)
                         && (prior?.pendingDispatchBaselineReset === true
                             || session.resumed !== true);
-                    this.agents.set(agent, {
-                        config,
-                        session,
-                        monitor,
-                        resultReady,
-                        resultState,
-                        freshForPendingDispatch,
-                        launchTurnExpected: session.resumed !== true || prompt.length > 0,
-                    });
-                    monitor.startHistoryPolling();
+                    // Initialize before observation can publish a new checkpoint or rewind.
                     await this.store.update((state) => {
                         const dispatch = state.generation.dispatch;
                         if (freshForPendingDispatch
                             && state.generation.id === persisted.generation.id
                             && dispatch !== undefined
-                            && persisted.generation.dispatch !== undefined
-                            && dispatch.token === persisted.generation.dispatch.token) {
+                            && persistedDispatch !== undefined
+                            && dispatch.token === persistedDispatch.token) {
                             if (dispatch.phase === "crosscheck") {
                                 state.generation.consumed = false;
                             }
@@ -244,27 +226,73 @@ export class CrosscheckCoordinator {
                             ...(freshForPendingDispatch && {
                                 pendingDispatchBaselineReset: true,
                             }),
-                            ...(persisted.sessions[agent]?.historySnapshot && {
-                                historySnapshot: persisted.sessions[agent].historySnapshot,
+                            ...(prior?.historySnapshot && {
+                                historySnapshot: prior.historySnapshot,
                             }),
                         };
                     });
-                    if (freshForPendingDispatch
-                        && session.resumed === true
-                        && activityState === "idle"
-                        && !this.agents.get(agent)?.launchTurnExpected) {
-                        await this.handleAgentIdle(agent);
+                    let usingObserverMonitor = false;
+                    const monitorOptions = {
+                        pendingEvidencePolicy: "wait",
+                        initialHistorySnapshot: persisted.sessions[agent]?.historySnapshot,
+                        onHistorySnapshot: (snapshot) => {
+                            if (this.finishing)
+                                return;
+                            this.runDispatchOperation(agent, this.store.updateSessionHistory(agent, snapshot), "persist session history");
+                        },
+                        onHistoryRegression: (_regression, snapshot) => {
+                            if (this.finishing)
+                                return;
+                            this.runDispatchOperation(agent, this.invalidateGenerationForRewind(agent, snapshot), "invalidate rewound generation");
+                        },
+                        onChange: (idle) => {
+                            if (this.finishing)
+                                return;
+                            this.refreshStatusHint();
+                            this.options.host.scheduleParentUiRender();
+                            if (idle && this.sessionsReady) {
+                                const progressIdentity = this.takeCrosscheckTurnIdentity(agent);
+                                this.runDispatchOperation(agent, this.handleAgentIdle(agent, progressIdentity), "prepare resumed crosscheck");
+                            }
+                        },
+                        onReadFailure: () => {
+                            this.options.output.warn(usingObserverMonitor
+                                ? `${config.driver} ${agentLabel(agent)} session observation is unavailable; crosscheck remains disarmed`
+                                : `${config.driver} ${agentLabel(agent)} session log is unreadable; crosscheck remains disarmed`);
+                        },
+                    };
+                    const observerMonitor = session.createTurnMonitor?.(monitorOptions);
+                    usingObserverMonitor = observerMonitor !== undefined;
+                    const monitor = observerMonitor ?? new SessionTurnMonitor(config.driver, session.identity.sessionFilePath, session.baseline, monitorOptions);
+                    this.agents.set(agent, {
+                        config,
+                        session,
+                        monitor,
+                        resultReady,
+                        resultState,
+                        freshForPendingDispatch,
+                        launchTurnExpected: session.resumed !== true || prompt.length > 0,
+                        launchTurnReceipt,
+                    });
+                    this.launchingSessions.delete(agent);
+                    if (this.agents.get(agent).launchTurnExpected) {
+                        if (typeof monitor.attachTurn === "function")
+                            monitor.attachTurn(launchTurnReceipt);
+                        else
+                            monitor.beginTurn();
                     }
+                    monitor.startHistoryPolling();
                 }
                 catch (err) {
                     this.launchingSessions.get(agent)?.close();
                     this.launchingSessions.delete(agent);
+                    const launchFailure = observerLaunchFailureError(config.driver, agent, err);
                     if (!hasLaunchFailure) {
                         hasLaunchFailure = true;
-                        firstLaunchFailure = err;
-                        launchAbort.abort(err);
+                        firstLaunchFailure = launchFailure;
+                        launchAbort.abort(launchFailure);
                     }
-                    throw err;
+                    throw launchFailure;
                 }
             });
             const launchResults = await Promise.allSettled(launches);
@@ -274,15 +302,14 @@ export class CrosscheckCoordinator {
                 throw firstLaunchFailure;
             if (this.finishing)
                 return await completion;
-            this.sessionsReady = true;
-            this.refreshStatusHint();
-            this.options.host.scheduleParentUiRender();
             for (const runtime of this.agents.values()) {
                 if (runtime.launchTurnExpected)
-                    runtime.monitor.beginTurn();
+                    runtime.monitor.beginTurn(runtime.launchTurnReceipt);
             }
-            await this.reconcilePersistedDispatch();
-            await this.maybeSettleReconcileGate();
+            this.sessionsReady = true;
+            this.refreshStatusHint();
+            this.options.host.scheduleParentUiRender();
+            await this.reconcileLaunchDispatch();
             this.broadcast.reconcileMode(this.currentReadiness(), this.currentGenerationPresentation());
             this.refreshMouseModes();
             this.resultTimer = setInterval(() => {
@@ -542,6 +569,8 @@ export class CrosscheckCoordinator {
                 continue;
             }
             if (isControlKey(event, 0x18)) {
+                if (this.finishing)
+                    continue;
                 flush();
                 const canRetry = this.canRetryPendingDispatch();
                 const canCrosscheck = this.isCrosscheckArmed();
@@ -567,6 +596,8 @@ export class CrosscheckCoordinator {
                 if (this.routeMouse(event, mouseFrame))
                     continue;
             }
+            if (this.finishing)
+                continue;
             if (this.focus === "broadcast") {
                 flush();
                 const submissionState = this.currentSubmissionState();
@@ -604,6 +635,8 @@ export class CrosscheckCoordinator {
         return true;
     }
     onClipboardPasteRequest() {
+        if (this.finishing)
+            return true;
         if (this.focus !== "broadcast")
             return false;
         this.requestBroadcastPaste();
@@ -697,6 +730,8 @@ export class CrosscheckCoordinator {
         const runtime = this.agents.get(target.agent);
         if (!runtime || point.row <= HEADER_ROWS)
             return true;
+        if (this.finishing && event.kind !== "wheel")
+            return true;
         const localRow = point.row - HEADER_ROWS;
         if (event.kind === "wheel"
             && !runtime.session.vt.isAlternate
@@ -738,6 +773,8 @@ export class CrosscheckCoordinator {
         return true;
     }
     forwardMouseFrameToAgent(agent, frame) {
+        if (this.finishing)
+            return;
         const runtime = this.agents.get(agent);
         if (!runtime)
             return;
@@ -893,9 +930,13 @@ export class CrosscheckCoordinator {
         return "ready";
     }
     requestBroadcastPaste() {
+        if (this.finishing)
+            return;
         void handleImagePasteIntent(this.broadcast.attachments, () => {
             this.flashTransient(PASTING_IMAGE_HINT, 3000);
         }).then((outcome) => {
+            if (this.finishing)
+                return;
             if (outcome.inserted !== undefined) {
                 this.broadcast.applyInsertedText(outcome.inserted);
                 this.resizeSessions();
@@ -913,7 +954,7 @@ export class CrosscheckCoordinator {
         return this.isCrosscheckArmed() || this.isReconcileArmed();
     }
     isCrosscheckArmed() {
-        if (!this.store || !this.sessionsReady)
+        if (this.finishing || !this.store || !this.sessionsReady)
             return false;
         if (this.store.generationInvalidated())
             return false;
@@ -923,7 +964,7 @@ export class CrosscheckCoordinator {
         return this.allResultsReady() && this.allAgentsIdle();
     }
     isReconcileArmed() {
-        if (!this.store || !this.sessionsReady)
+        if (this.finishing || !this.store || !this.sessionsReady)
             return false;
         if (this.store.generationInvalidated())
             return false;
@@ -952,11 +993,12 @@ export class CrosscheckCoordinator {
         return status !== undefined && status !== "delivered";
     }
     canRetryPendingDispatch() {
-        if (!this.store)
+        if (this.finishing || !this.store)
             return false;
         const dispatchPhase = this.store.dispatchPhase();
         if (this.dispatching
             || !this.sessionsReady
+            || this.launchReconciliationPending
             || dispatchPhase === undefined
             || (this.store.generationConsumed() && dispatchPhase === "crosscheck")
             || !this.allResultsReady()
@@ -1120,28 +1162,50 @@ export class CrosscheckCoordinator {
         let submitted = false;
         const provider = resolveProvider(runtime.config.driver);
         const releaseInputLock = this.lockAutomatedInput(agent);
+        let receipt;
+        const markSubmitted = () => {
+            receipt?.markWritten();
+            if (!receipt || submitted || !this.isCurrentGenerationOperation(generationId, operation))
+                return;
+            submitted = true;
+            if (progressAttemptId) {
+                this.markCrosscheckSlotSubmitted(agent, generationId, dispatch.token, progressAttemptId);
+                const identity = { generationId, dispatchToken: dispatch.token, attemptId: progressAttemptId };
+                receipt.onSettled((result) => {
+                    if ((result !== "completed" && result !== "cancelled")
+                        || !this.isCurrentGenerationOperation(generationId, operation))
+                        return;
+                    this.settleCrosscheckSlot(agent, identity);
+                    this.runDispatchOperation(agent, this.handleAgentIdle(agent, identity), "settle crosscheck request");
+                });
+            }
+        };
         try {
+            receipt = await runtime.monitor.reserveTurnFromSession();
             await (this.options.sendInquiry ?? sendInquiryQuestion)(runtime.session, this.buildDispatchPrompt(agent, generationId, dispatch.phase, dispatch.round), {
                 signal: operation.signal,
                 composer: provider.composer,
+                onSubmitWritten: markSubmitted,
                 onSubmitted: () => {
                     if (!this.isCurrentGenerationOperation(generationId, operation))
                         return;
-                    submitted = true;
-                    if (progressAttemptId) {
-                        this.markCrosscheckSlotSubmitted(agent, generationId, dispatch.token, progressAttemptId);
-                    }
-                    runtime.monitor.beginTurn();
+                    markSubmitted();
+                    runtime.monitor.beginTurn(receipt);
                 },
             });
         }
         finally {
             releaseInputLock();
+            receipt?.release();
+            if (submitted && this.isCurrentGenerationOperation(generationId, operation)) {
+                await this.transitionDispatchStatus(agent, generationId, dispatch.token, "pending", "submitted");
+                if (runtime.monitor.isIdle)
+                    await this.handleAgentIdle(agent);
+            }
         }
         if (!submitted || !this.isCurrentGenerationOperation(generationId, operation))
             return;
-        await this.transitionDispatchStatus(agent, generationId, dispatch.token, "pending", "submitted");
-        const classification = await provider.live.classifyDispatchDelivery(runtime.session.identity.sessionFilePath, dispatch.agents[agent].baseline);
+        const classification = await this.classifyRuntimeDispatchDelivery(runtime, dispatch.agents[agent].baseline);
         if (!this.isCurrentGenerationOperation(generationId, operation))
             return;
         if (classification === "present") {
@@ -1150,6 +1214,8 @@ export class CrosscheckCoordinator {
         if (!this.isCurrentGenerationOperation(generationId, operation))
             return;
         await this.finalizeDispatchIfComplete(generationId);
+        // The matching turns may have settled before delivery confirmation finished.
+        await this.maybeSettleReconcileGate();
     }
     buildDispatchPrompt(agent, generationId, phase, round) {
         const other = otherAgent(agent);
@@ -1165,7 +1231,23 @@ export class CrosscheckCoordinator {
         const ownJsonFile = reconcileJsonFilePath(this.options.persistentDir, agent, generationId, round);
         return buildExecutorReconcilePrompt(otherJsonFile, ownJsonFile);
     }
+    async reconcileLaunchDispatch() {
+        if (!this.launchReconciliationPending
+            || !this.sessionsReady
+            || !this.allAgentsIdle())
+            return;
+        // Release once: later dispatches still reconcile each side independently.
+        this.launchReconciliationPending = false;
+        for (const agent of this.agents.keys())
+            await this.handleAgentIdle(agent);
+        await this.reconcilePersistedDispatch();
+        await this.maybeSettleReconcileGate();
+    }
     async reconcilePersistedDispatch() {
+        if (this.launchReconciliationPending) {
+            await this.reconcileLaunchDispatch();
+            return;
+        }
         const snapshot = this.store.snapshot();
         const generationId = snapshot.generation.id;
         const dispatch = snapshot.generation.dispatch;
@@ -1185,6 +1267,7 @@ export class CrosscheckCoordinator {
     async retryPersistedDispatch() {
         if (this.dispatching
             || !this.sessionsReady
+            || this.launchReconciliationPending
             || !this.allResultsReady()
             || !this.allAgentsIdle())
             return;
@@ -1235,18 +1318,9 @@ export class CrosscheckCoordinator {
     async reconcileDispatchSide(agent, generationId, dispatch, expectedStatus, onAbsent, operation = this.currentDispatchOperationContext()) {
         if (!this.isCurrentGenerationOperation(generationId, operation))
             return false;
-        const target = onAbsent
-            ? (() => {
-                const runtime = this.agents.get(agent);
-                return runtime
-                    ? {
-                        driver: runtime.config.driver,
-                        sessionFilePath: runtime.session.identity.sessionFilePath,
-                    }
-                    : undefined;
-            })()
-            : this.store.snapshot().sessions[agent];
-        if (!target) {
+        const runtimeTarget = onAbsent ? this.agents.get(agent) : undefined;
+        const persistedTarget = onAbsent ? undefined : this.store.snapshot().sessions[agent];
+        if (!runtimeTarget && !persistedTarget) {
             if (!onAbsent
                 &&
                     this.isCurrentDispatchSide(agent, generationId, dispatch.token, expectedStatus)) {
@@ -1254,11 +1328,13 @@ export class CrosscheckCoordinator {
             }
             return true;
         }
-        if ("pendingDispatchBaselineReset" in target && target.pendingDispatchBaselineReset) {
+        if (persistedTarget?.pendingDispatchBaselineReset) {
             return true;
         }
-        const classification = await resolveProvider(target.driver)
-            .live.classifyDispatchDelivery(target.sessionFilePath, dispatch.agents[agent].baseline);
+        const classification = runtimeTarget
+            ? await this.classifyRuntimeDispatchDelivery(runtimeTarget, dispatch.agents[agent].baseline)
+            : await resolveProvider(persistedTarget.driver)
+                .live.classifyDispatchDelivery(persistedTarget.sessionFilePath, dispatch.agents[agent].baseline);
         if (!this.isCurrentGenerationOperation(generationId, operation))
             return false;
         if (!this.isCurrentDispatch(generationId, dispatch.token))
@@ -1334,6 +1410,8 @@ export class CrosscheckCoordinator {
         this.refreshStatusHint();
     }
     async maybeSettleReconcileGate() {
+        if (this.finishing)
+            return;
         const snapshot = this.store.snapshot();
         if (snapshot.generation.reconcilePendingSettlement
             && !snapshot.generation.dispatch
@@ -1404,6 +1482,12 @@ export class CrosscheckCoordinator {
         this.refreshStatusHint();
         this.options.host.scheduleParentUiRender();
     }
+    async classifyRuntimeDispatchDelivery(runtime, baseline) {
+        const liveClassification = runtime.monitor.classifyDeliverySince?.(baseline);
+        if (liveClassification)
+            return liveClassification;
+        return await resolveProvider(runtime.config.driver).live.classifyDispatchDelivery(runtime.session.identity.sessionFilePath, baseline);
+    }
     markDispatchDelivered(agent, generationId, dispatchToken, expectedStatus) {
         return this.transitionDispatchStatus(agent, generationId, dispatchToken, expectedStatus, "delivered");
     }
@@ -1433,6 +1517,8 @@ export class CrosscheckCoordinator {
     }
     /** Sends the committed Broadcast text and, for Steer/Follow-up, starts the next generation first. */
     async submitBroadcast() {
+        if (this.finishing)
+            return;
         const text = this.broadcast.submissionText();
         if (text === undefined)
             return;
@@ -1538,6 +1624,7 @@ export class CrosscheckCoordinator {
                 : text;
         const provider = resolveProvider(runtime.config.driver);
         const releaseInputLock = this.lockAutomatedInput(agent);
+        let receipt;
         try {
             if (generationKind && provider.cancelSequence) {
                 await sendCancelSequence(runtime.session.pty, provider.cancelSequence, operation.signal, runtime.monitor.isIdle);
@@ -1545,19 +1632,22 @@ export class CrosscheckCoordinator {
             if (!this.isCurrentGenerationOperation(generationId, operation, { allowRewound: conversational })) {
                 return;
             }
+            receipt = await runtime.monitor.reserveTurnFromSession();
             await (this.options.sendInquiry ?? sendInquiryQuestion)(runtime.session, prompt, {
                 signal: operation.signal,
                 composer: provider.composer,
+                onSubmitWritten: () => receipt?.markWritten(),
                 onSubmitted: () => {
                     if (!this.isCurrentGenerationOperation(generationId, operation, { allowRewound: conversational }))
                         return;
-                    runtime.monitor.beginTurn();
+                    runtime.monitor.beginTurn(receipt);
                 },
                 ...(generationKind ? { escapeBeforePaste: true } : {}),
             });
         }
         finally {
             releaseInputLock();
+            receipt?.release();
         }
     }
     refreshResults() {
@@ -1579,8 +1669,9 @@ export class CrosscheckCoordinator {
             agent,
             ready: await fileHasContent(generation.resultFiles[agent]),
         })));
-        // Guard against a late read from a generation the coordinator has since superseded.
-        if (this.store.snapshot().generation.id !== generation.id)
+        // A same-generation rewind also invalidates an outstanding result read.
+        const current = this.store.snapshot().generation;
+        if (this.finishing || current.id !== generation.id || current.rewind)
             return;
         for (const { agent, ready } of readiness) {
             const runtime = this.agents.get(agent);
@@ -1649,6 +1740,7 @@ export class CrosscheckCoordinator {
         if (this.finishing
             || this.dispatching
             || !this.sessionsReady
+            || this.launchReconciliationPending
             || this.resendAfterLaunch.size === 0
             || !this.allResultsReady()
             || [...this.agents.values()].some((runtime) => runtime.freshForPendingDispatch)
@@ -1658,6 +1750,12 @@ export class CrosscheckCoordinator {
         this.runDispatchOperation(undefined, this.retryPersistedDispatch(), "resume crosscheck");
     }
     async handleAgentIdle(agent, progressIdentity = this.takeCrosscheckTurnIdentity(agent)) {
+        if (this.finishing)
+            return;
+        if (this.launchReconciliationPending) {
+            await this.reconcileLaunchDispatch();
+            return;
+        }
         this.settleCrosscheckSlot(agent, progressIdentity);
         const runtime = this.agents.get(agent);
         if (runtime?.freshForPendingDispatch
@@ -1694,8 +1792,7 @@ export class CrosscheckCoordinator {
         if (runtime
             && dispatch?.agents[agent].status === "submitted"
             && !runtime.freshForPendingDispatch) {
-            const classification = await resolveProvider(runtime.config.driver)
-                .live.classifyDispatchDelivery(runtime.session.identity.sessionFilePath, dispatch.agents[agent].baseline);
+            const classification = await this.classifyRuntimeDispatchDelivery(runtime, dispatch.agents[agent].baseline);
             if (!this.isCurrentDispatch(snapshot.generation.id, dispatch.token)) {
                 this.maybeRetryPersistedDispatch();
                 return;
@@ -1773,6 +1870,7 @@ export class CrosscheckCoordinator {
         this.launchAbort?.abort(new Error("Crosscheck launch cancelled"));
         this.dispatchAbort.abort(new Error("Crosscheck coordinator stopped"));
         this.abortActiveDispatchOperations(new Error("Crosscheck coordinator stopped"));
+        this.options.host.scheduleParentUiRender();
         this.finishResolve?.({ kind: "crosscheck", interrupted: true });
     }
     fail(error) {
@@ -1799,24 +1897,32 @@ export class CrosscheckCoordinator {
         if (this.activityTimer)
             clearInterval(this.activityTimer);
         this.activityTimer = undefined;
-        if (this.transientFlash) {
-            clearTimeout(this.transientFlash.timer);
-            this.transientFlash = undefined;
+        try {
+            const monitors = await Promise.allSettled([...this.agents.values()].map((runtime) => runtime.monitor.shutdown()));
+            await Promise.allSettled([...this.dispatchOperations]);
+            await this.resultRefresh;
+            this.trackActivity();
+            await Promise.allSettled([...this.activityOperations]);
+            await this.store?.drain();
+            const failedMonitor = monitors.find((result) => result.status === "rejected");
+            if (failedMonitor?.status === "rejected")
+                throw failedMonitor.reason;
         }
-        this.detachUi?.();
-        this.detachUi = undefined;
-        this.options.host.clearMouseModeSource(MOUSE_SOURCE);
-        await Promise.all([...this.agents.values()].map((runtime) => runtime.monitor.shutdown()));
-        await Promise.allSettled([...this.dispatchOperations]);
-        this.trackActivity();
-        await Promise.allSettled([...this.activityOperations]);
-        for (const runtime of this.agents.values()) {
-            runtime.session.close();
+        finally {
+            for (const runtime of this.agents.values())
+                runtime.session.close();
+            for (const session of this.launchingSessions.values())
+                session.close();
+            if (this.transientFlash) {
+                clearTimeout(this.transientFlash.timer);
+                this.transientFlash = undefined;
+            }
+            this.detachUi?.();
+            this.detachUi = undefined;
+            this.options.host.clearMouseModeSource(MOUSE_SOURCE);
+            this.agents.clear();
+            this.launchingSessions.clear();
         }
-        for (const session of this.launchingSessions.values())
-            session.close();
-        this.agents.clear();
-        this.launchingSessions.clear();
     }
     runDispatchOperation(agent, operation, action) {
         const tracked = operation
@@ -1921,6 +2027,7 @@ export class CrosscheckCoordinator {
             catch {
                 // Result may not exist while the executor is still working.
             }
+            const observerDiagnostics = runtime?.session.observerDiagnostics?.() ?? [];
             return {
                 seq: index,
                 stepId: agent,
@@ -1934,6 +2041,9 @@ export class CrosscheckCoordinator {
                 sessionFilePaths: runtime ? [runtime.session.identity.sessionFilePath] : [],
                 inFlight: true,
                 ...(runtime && { ptyTailSnapshot: runtime.session.ptyTail.snapshot() }),
+                ...(observerDiagnostics && observerDiagnostics.length > 0 && {
+                    observerDiagnostics,
+                }),
             };
         }));
     }
@@ -1983,6 +2093,16 @@ export function buildCrosscheckConfigurations(values) {
 function otherAgent(agent) {
     return agent === "agent-1" ? "agent-2" : "agent-1";
 }
+function observerLaunchFailureError(driver, agent, cause) {
+    if (!(cause instanceof Error))
+        return cause;
+    return /\bobserver\b/i.test(cause.message)
+        ? observerFailureError(driver, agent, cause)
+        : cause;
+}
+function observerFailureError(driver, agent, cause) {
+    return new Error(`${driver} ${agentLabel(agent)} observer failed: ${cause.message}`, { cause });
+}
 function agentLabel(agent) {
     return agent === "agent-1" ? "Agent 1" : "Agent 2";
 }