poly-weaver 0.13.4 → 0.14.0

package/dist/crosscheck/coordinator.js

@@ -0,0 +1,1695 @@
+import { open, readFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { bold, MUTED_YELLOW_BG, padOrClip, reset, TRUE_BLACK_FG, } from "../ansi.js";
+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 { resolveProvider } from "../providers/registry.js";
+import { encodeKeysToBytes } from "../terminal/key-to-bytes.js";
+import { parseSgrMouseFrame, WHEEL_LINES_PER_EVENT, } from "../terminal/input-router.js";
+import { renderViewportLines, shouldShowVtCursor } from "../terminal/render.js";
+import { buildSplitSurface, computeSplitMetrics, SPLIT_COLLAPSE_AT_COLS, } from "../user/split-surface.js";
+import { LiveAgentSession } from "./live-agent-session.js";
+import { crosscheckJsonFilePath, CrosscheckStateStore, reconcileJsonFilePath, } from "./state.js";
+import { abortableSleep } from "../util/abortable-sleep.js";
+import { readReviewResult } from "./reconcile.js";
+import { availableBroadcastModes, BroadcastComposer, } from "./broadcast-composer.js";
+import { isControlKey, isEnterKey } from "./key-helpers.js";
+import { TASK } from "../flow/types.js";
+import { isArtifactViewerKey } from "../dump/hotkey.js";
+const HEADER_ROWS = 1;
+const RESULT_POLL_MS = 300;
+const ACTIVITY_HEARTBEAT_MS = 60_000;
+const MOUSE_SOURCE = "crosscheck";
+const RESUME_CONTINUE_PROMPT = "Continue your work from where you were interrupted.";
+/** Rows reserved for the two agent panes even when Broadcast wants to grow further. */
+const MIN_AGENT_ROWS = 3;
+function dispatchAbortReason(signal) {
+    return signal.reason ?? new Error("Crosscheck dispatch cancelled");
+}
+function throwIfDispatchAborted(signal) {
+    if (signal.aborted)
+        throw dispatchAbortReason(signal);
+}
+function waitForCancelDelay(delayMs, signal) {
+    if (delayMs <= 0)
+        return Promise.resolve();
+    return abortableSleep(delayMs, signal, { onAbort: "reject-reason" });
+}
+async function sendCancelSequence(pty, sequence, signal) {
+    const delayMs = Math.max(0, sequence.delayMs ?? 0);
+    for (const [index, input] of sequence.inputs.entries()) {
+        throwIfDispatchAborted(signal);
+        pty.write(input);
+        if (index < sequence.inputs.length - 1) {
+            await waitForCancelDelay(delayMs, signal);
+        }
+    }
+}
+export class CrosscheckCoordinator {
+    options;
+    agents = new Map();
+    launchingSessions = new Map();
+    focus = "broadcast";
+    /** The agent shown in the narrow single-pane layout; retained while Broadcast is focused. */
+    visibleAgent = "agent-1";
+    broadcast = new BroadcastComposer({
+        agent1Ready: false,
+        agent2Ready: false,
+    });
+    store;
+    resultTimer;
+    activityTimer;
+    detachUi;
+    finishResolve;
+    finishReject;
+    finishing = false;
+    pendingFailure;
+    dispatching = false;
+    broadcastSendActive = false;
+    dispatchAbort = new AbortController();
+    dispatchOperations = new Set();
+    activityOperations = new Set();
+    resendAfterLaunch = new Set();
+    reconciliationBlocked = new Set();
+    freshDispatchPreparations = new Set();
+    automatedInputOwners = new Set();
+    automatedInputDepth = new Map();
+    resultRefresh;
+    launchAbort;
+    sessionsReady = false;
+    transientFlash;
+    crosscheckProgress;
+    selectionAgent;
+    crosscheckTurnIdentities = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    sessionFor(agent) {
+        return this.agents.get(agent)?.session ?? this.launchingSessions.get(agent);
+    }
+    async run() {
+        this.store = await CrosscheckStateStore.open(this.options.persistentDir);
+        await this.store.ensureEffectiveTask(this.options.task);
+        await this.options.touchActivity?.();
+        try {
+            this.startActivityHeartbeat();
+            this.options.dumpService?.initConcurrent("crosscheck", this.options.flowParams, this.options.workdir, () => this.dumpRecords(), this.options.resumedFrom);
+            this.refreshStatusHint();
+            this.detachUi = this.options.host.attachParentUi(this);
+            const layout = this.options.host.getLayout();
+            const dimensions = this.paneDimensions(layout.columns, layout.childRows);
+            const persisted = this.store.snapshot();
+            const launchAbort = new AbortController();
+            this.launchAbort = launchAbort;
+            const completion = new Promise((resolve, reject) => {
+                this.finishResolve = resolve;
+                this.finishReject = reject;
+                if (this.pendingFailure !== undefined)
+                    reject(this.pendingFailure);
+            });
+            let hasLaunchFailure = false;
+            let firstLaunchFailure;
+            const launches = ["agent-1", "agent-2"].map(async (agent) => {
+                try {
+                    const config = this.options.configurations[agent];
+                    const resultFile = persisted.generation.resultFiles[agent];
+                    const resultReady = await fileHasContent(resultFile);
+                    const prior = persisted.sessions[agent];
+                    const resumeIdentity = prior?.driver === config.driver
+                        ? {
+                            sessionId: prior.sessionId,
+                            sessionFilePath: prior.sessionFilePath,
+                        }
+                        : undefined;
+                    const resumePrompt = persisted.generation.kind === "steer"
+                        ? buildExecutorSteerPrompt(persisted.generation.prompt, resultFile)
+                        : persisted.generation.kind === "follow-up"
+                            ? buildExecutorFollowUpPrompt(persisted.generation.prompt, resultFile)
+                            : buildExecutorInitialPrompt(this.options.task, resultFile);
+                    const freshPrompt = persisted.generation.kind === "steer"
+                        ? buildExecutorSteerFreshPrompt(persisted.generation.effectiveTask ?? this.options.task, persisted.generation.steerHistory, resultFile)
+                        : resumePrompt;
+                    const activityState = resumeIdentity
+                        ? await resolveProvider(config.driver).live.classifyActivityState(prior.sessionFilePath)
+                        : undefined;
+                    const priorSubmitCount = persisted.generation.deliverySubmitCounts?.[agent];
+                    const generationDelivered = resultReady
+                        ? true
+                        : resumeIdentity && priorSubmitCount !== undefined
+                            ? await resolveProvider(config.driver).live.classifyGenerationDelivery(prior.sessionFilePath, priorSubmitCount) === "present"
+                            : undefined;
+                    const prompt = generationDelivered === false
+                        ? resumePrompt
+                        : activityState === "idle"
+                            ? ""
+                            : activityState === "working"
+                                ? RESUME_CONTINUE_PROMPT
+                                : resumePrompt;
+                    const session = await (this.options.launchSession ?? LiveAgentSession.launch)({
+                        driver: config.driver,
+                        workdir: this.options.workdir,
+                        prompt,
+                        freshPrompt,
+                        yolo: this.options.yolo,
+                        model: config.model,
+                        effort: config.effort,
+                        resumeIdentity,
+                        output: this.options.output,
+                        signal: launchAbort.signal,
+                        cols: dimensions[agent].cols,
+                        rows: dimensions[agent].rows,
+                        sessionFileWaitMs: this.options.sessionFileWaitMs,
+                        onRender: () => this.options.host.scheduleParentUiRender(),
+                        onOscClipboard: (data) => this.options.host.forwardOscClipboard(data),
+                        onSpawn: (session) => {
+                            this.launchingSessions.set(agent, session);
+                            this.options.host.scheduleParentUiRender();
+                        },
+                        onExit: (event) => {
+                            if (!this.finishing) {
+                                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, {
+                        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`);
+                        },
+                    });
+                    const persistedDispatch = persisted.generation.dispatch;
+                    const freshForPendingDispatch = persistedDispatch !== undefined
+                        && (persistedDispatch.phase === "crosscheck"
+                            ? !persisted.generation.consumed
+                            : true)
+                        && (prior?.pendingDispatchBaselineReset === true
+                            || session.resumed !== true);
+                    this.agents.set(agent, {
+                        config,
+                        session,
+                        monitor,
+                        resultReady,
+                        freshForPendingDispatch,
+                        launchTurnExpected: session.resumed !== true || prompt.length > 0,
+                    });
+                    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) {
+                            if (dispatch.phase === "crosscheck") {
+                                state.generation.consumed = false;
+                            }
+                            dispatch.agents[agent].status = "pending";
+                        }
+                        state.sessions[agent] = {
+                            driver: config.driver,
+                            ...session.identity,
+                            ...(freshForPendingDispatch && {
+                                pendingDispatchBaselineReset: true,
+                            }),
+                        };
+                    });
+                    if (freshForPendingDispatch
+                        && session.resumed === true
+                        && activityState === "idle"
+                        && !this.agents.get(agent)?.launchTurnExpected) {
+                        await this.handleAgentIdle(agent);
+                    }
+                }
+                catch (err) {
+                    this.launchingSessions.get(agent)?.close();
+                    this.launchingSessions.delete(agent);
+                    if (!hasLaunchFailure) {
+                        hasLaunchFailure = true;
+                        firstLaunchFailure = err;
+                        launchAbort.abort(err);
+                    }
+                    throw err;
+                }
+            });
+            const launchResults = await Promise.allSettled(launches);
+            const failedLaunch = launchResults.find((result) => result.status === "rejected");
+            this.launchAbort = undefined;
+            if (failedLaunch && !this.finishing)
+                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();
+            }
+            await this.reconcilePersistedDispatch();
+            await this.maybeSettleReconcileGate();
+            this.broadcast.reconcileMode(this.currentReadiness());
+            this.refreshMouseModes();
+            this.resultTimer = setInterval(() => {
+                void this.refreshResults();
+            }, RESULT_POLL_MS);
+            await this.refreshResults();
+            this.maybeRetryPersistedDispatch();
+            return await completion;
+        }
+        finally {
+            await this.dispose();
+        }
+    }
+    getSurface() {
+        const layout = this.options.host.getLayout();
+        const totalRows = layout.childRows;
+        const broadcastRows = this.broadcastRowCount(layout.columns, totalRows);
+        const agentAreaRows = Math.max(1, totalRows - broadcastRows);
+        const metrics = computeSplitMetrics({
+            cols: layout.columns,
+            rows: agentAreaRows,
+            collapseAt: SPLIT_COLLAPSE_AT_COLS,
+        });
+        const splitOptions = {
+            cols: layout.columns,
+            rows: agentAreaRows,
+            collapseAt: SPLIT_COLLAPSE_AT_COLS,
+        };
+        const top = metrics.collapsed
+            ? buildSplitSurface(this.renderPane(this.visibleAgent, metrics.leftWidth, agentAreaRows), null, splitOptions)
+            : buildSplitSurface(this.renderPane("agent-1", metrics.leftWidth, agentAreaRows), this.renderPane("agent-2", metrics.rightWidth, agentAreaRows), splitOptions, this.focus === "agent-2" ? "right" : "left");
+        const crosscheck = this.currentCrosscheckStatus();
+        const submissionState = this.currentSubmissionState(crosscheck);
+        const broadcastPane = this.broadcast.render(layout.columns, this.focus === "broadcast", this.currentReadiness(), this.currentTrackedTask(), crosscheck, submissionState, broadcastRows, {
+            focusSwitchHint: this.focusSwitchHint(),
+            version: `poly-weaver v${APP_VERSION}`,
+            transient: this.currentTransientFlash(),
+        });
+        const lines = [...top.lines.slice(0, agentAreaRows), ...broadcastPane.lines];
+        while (lines.length < totalRows)
+            lines.push("");
+        if (lines.length > totalRows)
+            lines.length = totalRows;
+        const surface = { lines };
+        if (this.focus === "broadcast") {
+            surface.cursor = {
+                row: agentAreaRows + broadcastPane.cursor.row,
+                col: broadcastPane.cursor.col,
+            };
+            surface.showCursor = broadcastPane.showCursor;
+        }
+        else if (top.cursor) {
+            surface.cursor = top.cursor;
+            surface.showCursor = top.showCursor;
+        }
+        return surface;
+    }
+    selectionRegionAt(column, row) {
+        const layout = this.options.host.getLayout();
+        const totalRows = layout.childRows;
+        const broadcastRows = this.broadcastRowCount(layout.columns, totalRows);
+        const agentAreaRows = Math.max(1, totalRows - broadcastRows);
+        if (row <= agentAreaRows) {
+            if (row <= HEADER_ROWS)
+                return null;
+            const target = this.agentAtColumn(column);
+            if (!target)
+                return null; // separator column
+            const session = this.sessionFor(target.agent);
+            if (!session || session.vt.isAlternate)
+                return null;
+            const metrics = computeSplitMetrics({
+                cols: layout.columns,
+                rows: agentAreaRows,
+                collapseAt: SPLIT_COLLAPSE_AT_COLS,
+            });
+            if (metrics.collapsed) {
+                return {
+                    rowStart: HEADER_ROWS + 1,
+                    rowEnd: agentAreaRows,
+                    colStart: 1,
+                    colEnd: layout.columns,
+                };
+            }
+            if (column <= metrics.leftWidth) {
+                return {
+                    rowStart: HEADER_ROWS + 1,
+                    rowEnd: agentAreaRows,
+                    colStart: 1,
+                    colEnd: metrics.leftWidth,
+                };
+            }
+            return {
+                rowStart: HEADER_ROWS + 1,
+                rowEnd: agentAreaRows,
+                colStart: metrics.leftWidth + 2,
+                colEnd: layout.columns,
+            };
+        }
+        return {
+            rowStart: agentAreaRows + 1,
+            rowEnd: totalRows,
+            colStart: 1,
+            colEnd: layout.columns,
+        };
+    }
+    selectionTargetAt(column, row) {
+        const layout = this.options.host.getLayout();
+        const totalRows = layout.childRows;
+        const broadcastRows = this.broadcastRowCount(layout.columns, totalRows);
+        const agentAreaRows = Math.max(1, totalRows - broadcastRows);
+        if (row <= HEADER_ROWS || row > agentAreaRows)
+            return null;
+        const target = this.agentAtColumn(column);
+        if (!target)
+            return null;
+        const session = this.sessionFor(target.agent);
+        if (!session || session.vt.isAlternate)
+            return null;
+        return "offscreen-inquiry";
+    }
+    forkSelectionPlacement() {
+        const agent = this.selectionAgent;
+        if (!agent)
+            return undefined;
+        const session = this.sessionFor(agent);
+        if (!session || session.vt.isAlternate)
+            return undefined;
+        const layout = this.options.host.getLayout();
+        const totalRows = layout.childRows;
+        const broadcastRows = this.broadcastRowCount(layout.columns, totalRows);
+        const agentAreaRows = Math.max(1, totalRows - broadcastRows);
+        const metrics = computeSplitMetrics({
+            cols: layout.columns,
+            rows: agentAreaRows,
+            collapseAt: SPLIT_COLLAPSE_AT_COLS,
+        });
+        if (metrics.collapsed) {
+            if (agent !== this.visibleAgent)
+                return undefined;
+            return {
+                region: {
+                    rowStart: HEADER_ROWS + 1,
+                    rowEnd: agentAreaRows,
+                    colStart: 1,
+                    colEnd: layout.columns,
+                },
+                vt: session.vt,
+            };
+        }
+        if (agent === "agent-1") {
+            return {
+                region: {
+                    rowStart: HEADER_ROWS + 1,
+                    rowEnd: agentAreaRows,
+                    colStart: 1,
+                    colEnd: metrics.leftWidth,
+                },
+                vt: session.vt,
+            };
+        }
+        return {
+            region: {
+                rowStart: HEADER_ROWS + 1,
+                rowEnd: agentAreaRows,
+                colStart: metrics.leftWidth + 2,
+                colEnd: layout.columns,
+            },
+            vt: session.vt,
+        };
+    }
+    scrollSelectableSurfaceAt(column, row, direction) {
+        const layout = this.options.host.getLayout();
+        const totalRows = layout.childRows;
+        const broadcastRows = this.broadcastRowCount(layout.columns, totalRows);
+        const agentAreaRows = Math.max(1, totalRows - broadcastRows);
+        if (row <= HEADER_ROWS || row > agentAreaRows)
+            return 0;
+        const target = this.agentAtColumn(column);
+        if (!target)
+            return 0;
+        const session = this.sessionFor(target.agent);
+        if (!session || session.vt.isAlternate)
+            return 0;
+        const before = session.vt.viewportY;
+        if (direction === "back")
+            session.vt.scrollBack(1);
+        else
+            session.vt.scrollForward(1);
+        return Math.abs(session.vt.viewportY - before);
+    }
+    onSelectionGestureStart(row, column) {
+        const layout = this.options.host.getLayout();
+        const totalRows = layout.childRows;
+        const broadcastRows = this.broadcastRowCount(layout.columns, totalRows);
+        const agentAreaRows = Math.max(1, totalRows - broadcastRows);
+        if (row > HEADER_ROWS && row <= agentAreaRows) {
+            const target = this.agentAtColumn(column);
+            if (target) {
+                this.focus = target.agent;
+                this.visibleAgent = target.agent;
+                this.selectionAgent = target.agent;
+                this.resizeSessions();
+                this.refreshStatusHint();
+                this.options.host.scheduleParentUiRender();
+            }
+            return;
+        }
+        if (row > agentAreaRows && row <= totalRows) {
+            this.focus = "broadcast";
+        }
+    }
+    suppressesStatusBar() {
+        return true;
+    }
+    flashTransient(message, durationMs = 3000, variant = "default") {
+        if (this.transientFlash) {
+            clearTimeout(this.transientFlash.timer);
+        }
+        const timer = setTimeout(() => {
+            if (this.transientFlash?.timer !== timer)
+                return;
+            this.transientFlash = undefined;
+            this.options.host.scheduleParentUiRender();
+        }, durationMs);
+        this.transientFlash = { message, variant, timer };
+        this.options.host.scheduleParentUiRender();
+    }
+    onEvents(events) {
+        let forwarded = [];
+        let forwardedSide = this.focus === "broadcast" ? undefined : this.focus;
+        const flush = () => {
+            if (forwarded.length === 0)
+                return;
+            if (forwardedSide)
+                this.forwardEvents(forwardedSide, forwarded);
+            forwarded = [];
+        };
+        let broadcastChanged = false;
+        for (const event of events) {
+            if (this.focus === "broadcast"
+                && event.kind !== "escape"
+                && event.kind !== "printable") {
+                this.broadcast.endInputSequence();
+            }
+            if (isControlKey(event, 0x03)) {
+                flush();
+                this.finish();
+                break;
+            }
+            if (isArtifactViewerKey(event)) {
+                flush();
+                this.cycleFocus();
+                forwardedSide = this.focus === "broadcast" ? undefined : this.focus;
+                this.refreshStatusHint();
+                this.options.host.scheduleParentUiRender();
+                continue;
+            }
+            if (isControlKey(event, 0x18)) {
+                flush();
+                const canRetry = this.canRetryPendingDispatch();
+                const canCrosscheck = this.isCrosscheckArmed();
+                const canReconcile = this.isReconcileArmed();
+                if (this.focus === "broadcast" && canRetry) {
+                    this.runDispatchOperation(undefined, this.retryPersistedDispatch(), "retry crosscheck");
+                }
+                else if (this.focus === "broadcast" && canCrosscheck) {
+                    this.runDispatchOperation(undefined, this.startCrosscheckDispatch(), "start crosscheck");
+                }
+                else if (this.focus === "broadcast" && canReconcile) {
+                    this.runDispatchOperation(undefined, this.startReconcileDispatch(), "start reconcile");
+                }
+                continue;
+            }
+            if (event.kind === "wheel" || event.kind === "raw") {
+                flush();
+                forwardedSide = this.focus === "broadcast" ? undefined : this.focus;
+                if (this.routeMouse(event))
+                    continue;
+            }
+            if (this.focus === "broadcast") {
+                flush();
+                const submissionState = this.currentSubmissionState();
+                const outcome = this.broadcast.handleKey(event, this.currentReadiness(), submissionState);
+                if (outcome === "submit") {
+                    this.runDispatchOperation(undefined, this.submitBroadcast(), "broadcast send");
+                }
+                if (outcome === "changed" || outcome === "mode-cycle")
+                    broadcastChanged = true;
+                continue;
+            }
+            if (forwardedSide !== this.focus) {
+                flush();
+                forwardedSide = this.focus;
+            }
+            if (this.automatedInputOwners.has(this.focus)
+                || this.hasPendingCrosscheck(this.focus))
+                continue;
+            const runtime = this.agents.get(this.focus);
+            if (runtime && isEnterKey(event, runtime.session.childKittyFlags)) {
+                runtime.monitor.beginTurnAttempt();
+                this.refreshStatusHint();
+            }
+            forwarded.push(event);
+        }
+        flush();
+        this.broadcast.endInputSequence();
+        if (broadcastChanged) {
+            this.resizeSessions();
+            this.refreshStatusHint();
+            this.options.host.scheduleParentUiRender();
+        }
+        return true;
+    }
+    onResize() {
+        this.resizeSessions();
+    }
+    cycleFocus() {
+        const order = ["broadcast", "agent-1", "agent-2"];
+        const next = order[(order.indexOf(this.focus) + 1) % order.length];
+        this.focus = next;
+        if (next !== "broadcast")
+            this.visibleAgent = next;
+        this.resizeSessions();
+    }
+    nextFocusTarget() {
+        const order = ["broadcast", "agent-1", "agent-2"];
+        return order[(order.indexOf(this.focus) + 1) % order.length];
+    }
+    renderPane(agent, width, rows) {
+        const runtime = this.agents.get(agent);
+        const launchingSession = this.launchingSessions.get(agent);
+        const focused = this.focus === agent;
+        const config = runtime?.config ?? this.options.configurations[agent];
+        const monitor = runtime?.monitor;
+        const label = [
+            config.driver,
+            config.model,
+            config.effort,
+            monitor ? (monitor.isIdle ? "idle" : "working") : "starting",
+            runtime?.resultReady ? "done" : undefined,
+        ].filter(Boolean).join(" | ");
+        const color = focused
+            ? `${MUTED_YELLOW_BG}${TRUE_BLACK_FG}${bold}`
+            : "\x1b[7m";
+        const header = `${color}${padOrClip(` ${label} `, width)}${reset}`;
+        const session = runtime?.session ?? launchingSession;
+        if (!session) {
+            return { lines: [header] };
+        }
+        return {
+            lines: [
+                header,
+                ...renderViewportLines(session.vt, Math.max(0, rows - HEADER_ROWS), width),
+            ],
+            cursor: {
+                row: HEADER_ROWS + session.vt.cursorY,
+                col: session.vt.cursorX,
+            },
+            showCursor: focused && shouldShowVtCursor(session.vt),
+        };
+    }
+    routeMouse(event) {
+        const point = event.kind === "wheel"
+            ? { column: event.column, row: event.row, button: undefined, final: undefined }
+            : parseSgrMouseFrame(event);
+        if (!point)
+            return false;
+        const layout = this.options.host.getLayout();
+        const totalRows = layout.childRows;
+        const broadcastRows = this.broadcastRowCount(layout.columns, totalRows);
+        const agentAreaRows = Math.max(1, totalRows - broadcastRows);
+        if (point.row > agentAreaRows) {
+            if (event.kind === "raw"
+                && point.final === "M"
+                && point.button !== undefined
+                && (point.button & 3) === 0
+                && this.focus !== "broadcast") {
+                this.focus = "broadcast";
+                this.refreshStatusHint();
+                this.options.host.scheduleParentUiRender();
+            }
+            return true;
+        }
+        const target = this.agentAtColumn(point.column);
+        if (!target)
+            return true;
+        if (event.kind === "raw"
+            && point.final === "M"
+            && point.button !== undefined
+            && (point.button & 3) === 0) {
+            this.focus = target.agent;
+            this.visibleAgent = target.agent;
+            this.resizeSessions();
+            this.refreshStatusHint();
+            this.options.host.scheduleParentUiRender();
+        }
+        const runtime = this.agents.get(target.agent);
+        if (!runtime || point.row <= HEADER_ROWS)
+            return true;
+        const localRow = point.row - HEADER_ROWS;
+        if (event.kind === "wheel"
+            && !runtime.session.vt.isAlternate
+            && !runtime.session.hasMouseReporting()) {
+            if (event.direction === "up")
+                runtime.session.vt.scrollBack(WHEEL_LINES_PER_EVENT);
+            else
+                runtime.session.vt.scrollForward(WHEEL_LINES_PER_EVENT);
+            this.options.host.scheduleParentUiRender();
+            return true;
+        }
+        if (!runtime.session.hasMouseReporting() && !runtime.session.vt.isAlternate)
+            return true;
+        const translated = event.kind === "wheel"
+            ? { ...event, column: target.localColumn, row: localRow }
+            : {
+                kind: "raw",
+                bytes: Buffer.from(`\x1b[<${point.button};${target.localColumn};${localRow}${point.final}`, "ascii"),
+            };
+        const bytes = encodeKeysToBytes([translated], { wheelMode: "sgr" });
+        if (bytes.length > 0)
+            runtime.session.pty.write(bytes);
+        return true;
+    }
+    agentAtColumn(column) {
+        const layout = this.options.host.getLayout();
+        const totalRows = layout.childRows;
+        const agentAreaRows = Math.max(1, totalRows - this.broadcastRowCount(layout.columns, totalRows));
+        const metrics = computeSplitMetrics({
+            cols: layout.columns,
+            rows: agentAreaRows,
+            collapseAt: SPLIT_COLLAPSE_AT_COLS,
+        });
+        if (metrics.collapsed) {
+            return { agent: this.visibleAgent, localColumn: Math.max(1, column) };
+        }
+        if (column <= metrics.leftWidth) {
+            return { agent: "agent-1", localColumn: Math.max(1, column) };
+        }
+        if (column === metrics.leftWidth + 1)
+            return undefined;
+        return {
+            agent: "agent-2",
+            localColumn: Math.max(1, column - metrics.leftWidth - 1),
+        };
+    }
+    currentReadiness() {
+        return {
+            agent1Ready: !!this.agents.get("agent-1")?.resultReady,
+            agent2Ready: !!this.agents.get("agent-2")?.resultReady,
+        };
+    }
+    currentResultFile(agent) {
+        return this.store.snapshot().generation.resultFiles[agent];
+    }
+    currentTrackedTask() {
+        if (!this.store)
+            return this.options.task;
+        const generation = this.store.snapshot().generation;
+        return generation.id === 0 ? this.options.task : generation.prompt;
+    }
+    currentCrosscheckStatus() {
+        const progress = this.crosscheckProgress;
+        if (progress
+            && this.store
+            && this.store.generationId() === progress.generationId) {
+            const completed = Object.values(progress.slots)
+                .filter((slot) => slot.settled).length;
+            return { kind: "crosschecking", phase: progress.phase, completed };
+        }
+        const retryPhase = this.retryDispatchPhase();
+        if (retryPhase)
+            return { kind: "actionable", phase: retryPhase };
+        if (this.isCrosscheckArmed()) {
+            return { kind: "actionable", phase: "crosscheck" };
+        }
+        if (this.isReconcileArmed()) {
+            return { kind: "actionable", phase: "reconcile" };
+        }
+        return { kind: "unavailable" };
+    }
+    currentSubmissionState(crosscheck = this.currentCrosscheckStatus()) {
+        if (!this.sessionsReady)
+            return "launching";
+        if (crosscheck.kind === "crosschecking")
+            return "crosschecking";
+        if (this.broadcastSendActive)
+            return "broadcasting";
+        return "ready";
+    }
+    isArmed() {
+        return this.isCrosscheckArmed() || this.isReconcileArmed();
+    }
+    isCrosscheckArmed() {
+        if (!this.store || !this.sessionsReady)
+            return false;
+        if (this.dispatching || this.store.generationConsumed() || this.store.hasDispatch()) {
+            return false;
+        }
+        return this.allResultsReady() && this.allAgentsIdle();
+    }
+    isReconcileArmed() {
+        if (!this.store || !this.sessionsReady)
+            return false;
+        if (this.dispatching
+            || !this.store.generationConsumed()
+            || this.store.hasDispatch()
+            || !this.store.reconcileAllowed()
+            || !this.store.reconcileSettled()
+            || this.store.reconcilePendingSettlement()
+            || this.store.reconcileJsonMissing())
+            return false;
+        return this.allAgentsIdle();
+    }
+    allResultsReady() {
+        const agent1 = this.agents.get("agent-1");
+        const agent2 = this.agents.get("agent-2");
+        return !!agent1?.resultReady && !!agent2?.resultReady;
+    }
+    allAgentsIdle() {
+        const agent1 = this.agents.get("agent-1");
+        const agent2 = this.agents.get("agent-2");
+        return !!agent1 && !!agent2 && agent1.monitor.isIdle && agent2.monitor.isIdle;
+    }
+    hasPendingCrosscheck(agent) {
+        const status = this.store?.dispatchAgentStatus(agent);
+        return status !== undefined && status !== "delivered";
+    }
+    canRetryPendingDispatch() {
+        if (!this.store)
+            return false;
+        const dispatchPhase = this.store.dispatchPhase();
+        if (this.dispatching
+            || !this.sessionsReady
+            || dispatchPhase === undefined
+            || (this.store.generationConsumed() && dispatchPhase === "crosscheck")
+            || !this.allResultsReady()
+            || !this.allAgentsIdle()
+            || [...this.agents.values()].some((runtime) => runtime.freshForPendingDispatch)) {
+            return false;
+        }
+        return ["agent-1", "agent-2"].some((agent) => this.store.dispatchAgentStatus(agent) === "pending"
+            && !this.reconciliationBlocked.has(agent));
+    }
+    retryDispatchPhase() {
+        if (!this.canRetryPendingDispatch())
+            return undefined;
+        return this.store.dispatchPhase();
+    }
+    beginCrosscheckProgress(generationId, dispatchToken, phase = "crosscheck") {
+        const attemptId = randomUUID();
+        this.crosscheckProgress = {
+            attemptId,
+            generationId,
+            dispatchToken,
+            phase,
+            slots: {
+                "agent-1": { submitted: false, settled: false },
+                "agent-2": { submitted: false, settled: false },
+            },
+        };
+        this.refreshStatusHint();
+        this.options.host.scheduleParentUiRender();
+        return attemptId;
+    }
+    markCrosscheckSlotSubmitted(agent, generationId, dispatchToken, attemptId) {
+        const progress = this.crosscheckProgress;
+        const generation = this.store.snapshot().generation;
+        if (!progress
+            || progress.attemptId !== attemptId
+            || progress.generationId !== generationId
+            || progress.dispatchToken !== dispatchToken
+            || generation.id !== generationId
+            || generation.dispatch?.token !== dispatchToken)
+            return;
+        progress.slots[agent].submitted = true;
+        this.crosscheckTurnIdentities.set(agent, {
+            generationId,
+            dispatchToken,
+            attemptId,
+        });
+    }
+    takeCrosscheckTurnIdentity(agent) {
+        const identity = this.crosscheckTurnIdentities.get(agent);
+        this.crosscheckTurnIdentities.delete(agent);
+        return identity;
+    }
+    settleCrosscheckSlot(agent, identity) {
+        const progress = this.crosscheckProgress;
+        if (!progress
+            || !identity
+            || progress.attemptId !== identity.attemptId
+            || progress.dispatchToken !== identity.dispatchToken
+            || progress.generationId !== identity.generationId
+            || progress.generationId !== this.store.snapshot().generation.id
+            || !progress.slots[agent].submitted
+            || progress.slots[agent].settled)
+            return;
+        progress.slots[agent].settled = true;
+        this.finishOrRenderCrosscheckProgress(progress);
+    }
+    settleUnsubmittedCrosscheckSlots(attemptId) {
+        const progress = this.crosscheckProgress;
+        if (!progress
+            || progress.attemptId !== attemptId
+            || progress.generationId !== this.store.snapshot().generation.id)
+            return;
+        for (const agent of ["agent-1", "agent-2"]) {
+            const slot = progress.slots[agent];
+            if (!slot.submitted && this.agents.get(agent)?.monitor.isIdle !== false) {
+                slot.settled = true;
+            }
+        }
+        this.finishOrRenderCrosscheckProgress(progress);
+    }
+    finishOrRenderCrosscheckProgress(progress) {
+        if (this.crosscheckProgress !== progress)
+            return;
+        if (Object.values(progress.slots).every((slot) => slot.settled)) {
+            this.crosscheckProgress = undefined;
+        }
+        this.refreshStatusHint();
+        this.options.host.scheduleParentUiRender();
+    }
+    async startCrosscheckDispatch() {
+        if (!this.isCrosscheckArmed())
+            return;
+        await this.startDispatch("crosscheck");
+    }
+    async startReconcileDispatch() {
+        if (!this.isReconcileArmed())
+            return;
+        const generation = this.store.snapshot().generation;
+        await this.startDispatch("reconcile", generation.reconcileRound + 1);
+    }
+    async startDispatch(phase, round) {
+        const generationId = this.store.generationId();
+        const token = randomUUID();
+        const attemptId = this.beginCrosscheckProgress(generationId, token, phase);
+        const agents = ["agent-1", "agent-2"];
+        try {
+            await this.withDispatchLifecycle(agents, async () => {
+                await this.store.update((state) => {
+                    if (state.generation.id !== generationId)
+                        return;
+                    state.generation.reconcileAllowed = false;
+                    state.generation.reconcileSettled = false;
+                    state.generation.dispatch = {
+                        token,
+                        phase,
+                        ...(round !== undefined && { round }),
+                        agents: {
+                            "agent-1": {
+                                status: "pending",
+                                baseline: this.agents.get("agent-1").monitor.lineBaseline,
+                            },
+                            "agent-2": {
+                                status: "pending",
+                                baseline: this.agents.get("agent-2").monitor.lineBaseline,
+                            },
+                        },
+                    };
+                });
+                const results = await Promise.allSettled(agents.map((agent) => this.sendDispatchAgent(agent, generationId, attemptId)));
+                for (const [index, result] of results.entries()) {
+                    if (result.status === "rejected") {
+                        this.warnDispatchFailure(agents[index], "send", result.reason);
+                    }
+                }
+                await this.finalizeDispatchIfComplete(generationId);
+            });
+        }
+        finally {
+            this.settleUnsubmittedCrosscheckSlots(attemptId);
+        }
+    }
+    async sendDispatchAgent(agent, generationId, progressAttemptId) {
+        if (this.reconciliationBlocked.has(agent))
+            return;
+        const state = this.store.snapshot();
+        if (state.generation.id !== generationId)
+            return;
+        const dispatch = state.generation.dispatch;
+        if (!dispatch || dispatch.agents[agent].status !== "pending")
+            return;
+        const runtime = this.agents.get(agent);
+        if (!runtime)
+            return;
+        let submitted = false;
+        const provider = resolveProvider(runtime.config.driver);
+        const releaseInputLock = this.lockAutomatedInput(agent);
+        try {
+            await (this.options.sendInquiry ?? sendInquiryQuestion)(runtime.session, this.buildDispatchPrompt(agent, generationId, dispatch.phase, dispatch.round), {
+                signal: this.dispatchAbort.signal,
+                composer: provider.composer,
+                onSubmitted: () => {
+                    submitted = true;
+                    if (progressAttemptId) {
+                        this.markCrosscheckSlotSubmitted(agent, generationId, dispatch.token, progressAttemptId);
+                    }
+                    runtime.monitor.beginTurn();
+                },
+            });
+        }
+        finally {
+            releaseInputLock();
+        }
+        if (!submitted)
+            return;
+        await this.transitionDispatchStatus(agent, generationId, dispatch.token, "pending", "submitted");
+        const classification = await provider.live.classifyDispatchDelivery(runtime.session.identity.sessionFilePath, dispatch.agents[agent].baseline);
+        if (classification === "present") {
+            await this.markDispatchDelivered(agent, generationId, dispatch.token, "submitted");
+        }
+        await this.finalizeDispatchIfComplete(generationId);
+    }
+    buildDispatchPrompt(agent, generationId, phase, round) {
+        const other = otherAgent(agent);
+        if (phase === "crosscheck") {
+            return buildExecutorCrosscheckPrompt(this.currentResultFile(other), crosscheckJsonFilePath(this.options.persistentDir, agent, generationId));
+        }
+        if (round === undefined) {
+            throw new Error("Cannot build reconcile prompt without a round");
+        }
+        const otherJsonFile = round === 1
+            ? crosscheckJsonFilePath(this.options.persistentDir, other, generationId)
+            : reconcileJsonFilePath(this.options.persistentDir, other, generationId, round - 1);
+        const ownJsonFile = reconcileJsonFilePath(this.options.persistentDir, agent, generationId, round);
+        return buildExecutorReconcilePrompt(otherJsonFile, ownJsonFile);
+    }
+    async reconcilePersistedDispatch() {
+        const snapshot = this.store.snapshot();
+        const generationId = snapshot.generation.id;
+        const dispatch = snapshot.generation.dispatch;
+        if (!dispatch || (snapshot.generation.consumed && dispatch.phase === "crosscheck")) {
+            return;
+        }
+        for (const agent of ["agent-1", "agent-2"]) {
+            const expectedStatus = dispatch.agents[agent].status;
+            if (expectedStatus === "delivered")
+                continue;
+            const current = await this.reconcileDispatchSide(agent, generationId, dispatch, expectedStatus);
+            if (!current)
+                return;
+        }
+        await this.finalizeDispatchIfComplete(generationId);
+    }
+    async retryPersistedDispatch() {
+        if (this.dispatching
+            || !this.sessionsReady
+            || !this.allResultsReady()
+            || !this.allAgentsIdle())
+            return;
+        const stateAtStart = this.store.snapshot();
+        const generationId = stateAtStart.generation.id;
+        const dispatchAtStart = stateAtStart.generation.dispatch;
+        if (!dispatchAtStart
+            || (stateAtStart.generation.consumed && dispatchAtStart.phase === "crosscheck"))
+            return;
+        const attemptId = this.beginCrosscheckProgress(generationId, dispatchAtStart.token, dispatchAtStart.phase);
+        const lockedAgents = ["agent-1", "agent-2"].filter((agent) => stateAtStart.generation.dispatch?.agents[agent].status === "pending"
+            && !this.reconciliationBlocked.has(agent));
+        try {
+            await this.withDispatchLifecycle(lockedAgents, async () => {
+                const state = this.store.snapshot();
+                if (state.generation.id !== generationId)
+                    return;
+                const dispatch = state.generation.dispatch;
+                if (!dispatch || (state.generation.consumed && dispatch.phase === "crosscheck")) {
+                    return;
+                }
+                for (const agent of ["agent-1", "agent-2"]) {
+                    const expectedStatus = dispatch.agents[agent].status;
+                    if (expectedStatus === "delivered")
+                        continue;
+                    if (this.reconciliationBlocked.has(agent))
+                        continue;
+                    const current = await this.reconcileDispatchSide(agent, generationId, dispatch, expectedStatus, async () => {
+                        try {
+                            await this.sendDispatchAgent(agent, generationId, attemptId);
+                        }
+                        catch (err) {
+                            this.warnDispatchFailure(agent, "retry", err);
+                        }
+                    });
+                    if (!current)
+                        return;
+                }
+                await this.finalizeDispatchIfComplete(generationId);
+            });
+        }
+        finally {
+            this.settleUnsubmittedCrosscheckSlots(attemptId);
+        }
+    }
+    async reconcileDispatchSide(agent, generationId, dispatch, expectedStatus, onAbsent) {
+        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) {
+            if (!onAbsent
+                &&
+                    this.isCurrentDispatchSide(agent, generationId, dispatch.token, expectedStatus)) {
+                this.resendAfterLaunch.add(agent);
+            }
+            return true;
+        }
+        if ("pendingDispatchBaselineReset" in target && target.pendingDispatchBaselineReset) {
+            return true;
+        }
+        const classification = await resolveProvider(target.driver)
+            .live.classifyDispatchDelivery(target.sessionFilePath, dispatch.agents[agent].baseline);
+        if (!this.isCurrentDispatch(generationId, dispatch.token))
+            return false;
+        if (!this.isCurrentDispatchSide(agent, generationId, dispatch.token, expectedStatus))
+            return true;
+        if (classification === "present") {
+            await this.markDispatchDelivered(agent, generationId, dispatch.token, expectedStatus);
+            if (this.isCurrentDispatchSide(agent, generationId, dispatch.token, "delivered"))
+                this.reconciliationBlocked.delete(agent);
+        }
+        else if (classification === "absent") {
+            await this.markDispatchPending(agent, generationId, dispatch.token, expectedStatus);
+            if (this.isCurrentDispatchSide(agent, generationId, dispatch.token, "pending")) {
+                this.reconciliationBlocked.delete(agent);
+                if (onAbsent) {
+                    await onAbsent();
+                }
+                else {
+                    this.resendAfterLaunch.add(agent);
+                }
+            }
+        }
+        else {
+            this.reconciliationBlocked.add(agent);
+            this.options.output.warn(onAbsent
+                ? `Cannot reconcile ${agentLabel(agent)} crosscheck; the prompt was not resent`
+                : `Cannot reconcile ${agentLabel(agent)} crosscheck; session log is unreadable and the prompt will not be resent`);
+        }
+        return true;
+    }
+    async withDispatchLifecycle(lockedAgents, dispatch) {
+        this.dispatching = true;
+        this.refreshStatusHint();
+        this.options.host.scheduleParentUiRender();
+        const releaseInputLocks = lockedAgents.map((agent) => this.lockAutomatedInput(agent));
+        try {
+            await dispatch();
+        }
+        finally {
+            for (const release of releaseInputLocks)
+                release();
+            this.dispatching = false;
+            this.refreshStatusHint();
+            this.options.host.scheduleParentUiRender();
+        }
+    }
+    async finalizeDispatchIfComplete(generationId) {
+        const state = this.store.snapshot();
+        const dispatch = state.generation.dispatch;
+        if (state.generation.id !== generationId || !dispatch)
+            return;
+        if (dispatch.agents["agent-1"].status !== "delivered"
+            || dispatch.agents["agent-2"].status !== "delivered")
+            return;
+        await this.store.update((next) => {
+            if (next.generation.id !== generationId)
+                return;
+            const current = next.generation.dispatch;
+            if (!current || current.token !== dispatch.token)
+                return;
+            if (current.phase === "crosscheck") {
+                next.generation.consumed = true;
+            }
+            else {
+                next.generation.reconcileRound = current.round ?? next.generation.reconcileRound;
+            }
+            next.generation.reconcilePendingSettlement = true;
+            delete next.generation.dispatch;
+        });
+        this.refreshStatusHint();
+    }
+    async maybeSettleReconcileGate() {
+        const snapshot = this.store.snapshot();
+        if (snapshot.generation.reconcilePendingSettlement
+            && !snapshot.generation.dispatch
+            && this.allAgentsIdle()) {
+            await this.settleReconcileGate(snapshot.generation.id);
+        }
+    }
+    async settleReconcileGate(generationId) {
+        const generation = this.store.snapshot().generation;
+        if (generation.id !== generationId
+            || !generation.reconcilePendingSettlement
+            || generation.dispatch)
+            return;
+        const round = generation.reconcileRound;
+        const paths = ["agent-1", "agent-2"].map((agent) => round === 0
+            ? crosscheckJsonFilePath(this.options.persistentDir, agent, generationId)
+            : reconcileJsonFilePath(this.options.persistentDir, agent, generationId, round));
+        const [agent1, agent2] = await Promise.all(paths.map((path) => readReviewResult(path)));
+        if (this.store.snapshot().generation.id !== generationId)
+            return;
+        if (!agent1 || !agent2) {
+            await this.store.update((state) => {
+                if (state.generation.id !== generationId
+                    || !state.generation.reconcilePendingSettlement
+                    || state.generation.dispatch)
+                    return;
+                state.generation.reconcileJsonMissing = true;
+                state.generation.reconcileAllowed = false;
+                state.generation.reconcileSettled = false;
+                state.generation.reconcilePendingSettlement = false;
+            });
+            this.options.output.warn("Crosscheck review JSON is missing or malformed; Ctrl+X Reconcile is unavailable.");
+            this.refreshStatusHint();
+            this.options.host.scheduleParentUiRender();
+            return;
+        }
+        const reconcileAllowed = round === 0
+            ? true
+            : agent1.rejected.length > 0 || agent2.rejected.length > 0;
+        await this.store.update((state) => {
+            if (state.generation.id !== generationId
+                || !state.generation.reconcilePendingSettlement
+                || state.generation.dispatch)
+                return;
+            state.generation.reconcileJsonMissing = false;
+            state.generation.reconcileAllowed = reconcileAllowed;
+            state.generation.reconcileSettled = true;
+            state.generation.reconcilePendingSettlement = false;
+        });
+        this.refreshStatusHint();
+        this.options.host.scheduleParentUiRender();
+    }
+    markDispatchDelivered(agent, generationId, dispatchToken, expectedStatus) {
+        return this.transitionDispatchStatus(agent, generationId, dispatchToken, expectedStatus, "delivered");
+    }
+    markDispatchPending(agent, generationId, dispatchToken, expectedStatus) {
+        return this.transitionDispatchStatus(agent, generationId, dispatchToken, expectedStatus, "pending");
+    }
+    transitionDispatchStatus(agent, generationId, dispatchToken, expectedStatus, nextStatus) {
+        return this.store.update((state) => {
+            if (state.generation.id === generationId
+                && state.generation.dispatch?.token === dispatchToken
+                && state.generation.dispatch.agents[agent].status === expectedStatus) {
+                state.generation.dispatch.agents[agent].status = nextStatus;
+            }
+        });
+    }
+    isCurrentDispatch(generationId, dispatchToken) {
+        const generation = this.store.snapshot().generation;
+        return generation.id === generationId
+            && generation.dispatch?.token === dispatchToken;
+    }
+    isCurrentDispatchSide(agent, generationId, dispatchToken, status) {
+        const generation = this.store.snapshot().generation;
+        return generation.id === generationId
+            && generation.dispatch?.token === dispatchToken
+            && generation.dispatch.agents[agent].status === status;
+    }
+    /** Sends the committed Broadcast text and, for Steer/Follow-up, starts the next generation first. */
+    async submitBroadcast() {
+        const text = this.broadcast.submissionText();
+        if (text === undefined)
+            return;
+        const mode = this.broadcast.mode;
+        if ((mode === "hint" || mode === "chat")
+            && ["agent-1", "agent-2"].some((agent) => this.hasPendingCrosscheck(agent)))
+            return;
+        const submission = this.broadcast.beginSubmission();
+        const agents = ["agent-1", "agent-2"];
+        let initiated = false;
+        this.broadcastSendActive = true;
+        this.refreshStatusHint();
+        this.options.host.scheduleParentUiRender();
+        try {
+            await this.withDispatchLifecycle(agents, async () => {
+                for (const agent of agents) {
+                    if (!this.agents.has(agent)) {
+                        throw new Error(`${agentLabel(agent)} is not ready for Broadcast`);
+                    }
+                }
+                if (mode === "steer" || mode === "follow-up") {
+                    const deliverySubmitCounts = await this.captureGenerationDeliveryCounts();
+                    await this.store.startGeneration(mode, text, deliverySubmitCounts);
+                    this.crosscheckProgress = undefined;
+                    for (const runtime of this.agents.values()) {
+                        runtime.resultReady = false;
+                        runtime.freshForPendingDispatch = false;
+                    }
+                    this.resendAfterLaunch.clear();
+                    this.reconciliationBlocked.clear();
+                    this.broadcast.resetModeForFreshGeneration();
+                    this.refreshStatusHint();
+                }
+                const generationId = this.store.snapshot().generation.id;
+                const generationKind = mode === "steer" || mode === "follow-up"
+                    ? mode
+                    : undefined;
+                const sends = agents.map((agent) => this.sendBroadcastAgent(agent, text, generationId, generationKind));
+                initiated = true;
+                this.broadcast.completeSubmission(submission);
+                this.resizeSessions();
+                this.options.host.scheduleParentUiRender();
+                const results = await Promise.allSettled(sends);
+                for (const [index, result] of results.entries()) {
+                    if (result.status === "rejected") {
+                        this.warnDispatchFailure(agents[index], "broadcast send", result.reason);
+                    }
+                }
+            });
+        }
+        finally {
+            this.broadcastSendActive = false;
+            this.refreshStatusHint();
+            this.options.host.scheduleParentUiRender();
+            if (!initiated)
+                this.broadcast.cancelSubmission(submission);
+        }
+    }
+    async captureGenerationDeliveryCounts() {
+        const runtimes = ["agent-1", "agent-2"].map((agent) => {
+            const runtime = this.agents.get(agent);
+            if (!runtime)
+                throw new Error(`${agentLabel(agent)} is not ready for Broadcast`);
+            return [agent, runtime];
+        });
+        await Promise.all(runtimes.map(([, runtime]) => runtime.monitor.waitForPendingTurnAttempts()));
+        const entries = await Promise.all(runtimes.map(async ([agent, runtime]) => {
+            const lines = await resolveProvider(runtime.config.driver).live.readLines(runtime.session.identity.sessionFilePath);
+            return [agent, runtime.monitor.expectedSubmitCount(lines)];
+        }));
+        return Object.fromEntries(entries);
+    }
+    async sendBroadcastAgent(agent, text, generationId, generationKind) {
+        const runtime = this.agents.get(agent);
+        if (!runtime)
+            throw new Error(`${agentLabel(agent)} is not ready for Broadcast`);
+        const generation = this.store.snapshot().generation;
+        if (generation.id !== generationId)
+            return;
+        const prompt = generationKind === "steer"
+            ? buildExecutorSteerPrompt(text, generation.resultFiles[agent])
+            : generationKind === "follow-up"
+                ? buildExecutorFollowUpPrompt(text, generation.resultFiles[agent])
+                : text;
+        const provider = resolveProvider(runtime.config.driver);
+        const releaseInputLock = this.lockAutomatedInput(agent);
+        try {
+            if (generationKind && provider.cancelSequence) {
+                await sendCancelSequence(runtime.session.pty, provider.cancelSequence, this.dispatchAbort.signal);
+            }
+            await (this.options.sendInquiry ?? sendInquiryQuestion)(runtime.session, prompt, {
+                signal: this.dispatchAbort.signal,
+                composer: provider.composer,
+                onSubmitted: () => runtime.monitor.beginTurn(),
+            });
+        }
+        finally {
+            releaseInputLock();
+        }
+    }
+    refreshResults() {
+        if (!this.resultRefresh) {
+            const refresh = this.performResultRefresh().finally(() => {
+                if (this.resultRefresh === refresh)
+                    this.resultRefresh = undefined;
+            });
+            this.resultRefresh = refresh;
+        }
+        return this.resultRefresh;
+    }
+    async performResultRefresh() {
+        let changed = false;
+        const generation = this.store.snapshot().generation;
+        const readiness = await Promise.all(["agent-1", "agent-2"].map(async (agent) => ({
+            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)
+            return;
+        for (const { agent, ready } of readiness) {
+            const runtime = this.agents.get(agent);
+            if (runtime && ready !== runtime.resultReady) {
+                runtime.resultReady = ready;
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.broadcast.reconcileMode(this.currentReadiness());
+            this.refreshStatusHint();
+            this.options.host.scheduleParentUiRender();
+            this.maybeRetryPersistedDispatch();
+        }
+    }
+    refreshStatusHint() {
+        // The crosscheck focus hint now renders on the Broadcast mode row.
+    }
+    focusSwitchHint() {
+        const nextTarget = this.nextFocusTarget();
+        const nextLabel = nextTarget === "broadcast" ? "Broadcast" : agentLabel(nextTarget);
+        return `Ctrl+] Focus ${nextLabel}`;
+    }
+    currentTransientFlash() {
+        if (!this.transientFlash)
+            return undefined;
+        return {
+            message: this.transientFlash.message,
+            variant: this.transientFlash.variant,
+        };
+    }
+    forwardEvents(agent, events) {
+        const runtime = this.agents.get(agent);
+        const session = runtime?.session ?? this.launchingSessions.get(agent);
+        if (!session)
+            return;
+        const useMouse = session.vt.isAlternate || session.hasMouseReporting();
+        const bytes = encodeKeysToBytes(events, {
+            ...(useMouse && { wheelMode: "sgr" }),
+            childKittyFlags: session.childKittyFlags,
+            childBracketedPaste: session.vt.bracketedPaste,
+        });
+        if (bytes.length > 0)
+            session.pty.write(bytes);
+    }
+    lockAutomatedInput(agent) {
+        const depth = (this.automatedInputDepth.get(agent) ?? 0) + 1;
+        this.automatedInputDepth.set(agent, depth);
+        this.automatedInputOwners.add(agent);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const next = (this.automatedInputDepth.get(agent) ?? 1) - 1;
+            if (next <= 0) {
+                this.automatedInputDepth.delete(agent);
+                this.automatedInputOwners.delete(agent);
+            }
+            else {
+                this.automatedInputDepth.set(agent, next);
+            }
+        };
+    }
+    maybeRetryPersistedDispatch() {
+        if (this.finishing
+            || this.dispatching
+            || !this.sessionsReady
+            || this.resendAfterLaunch.size === 0
+            || !this.allResultsReady()
+            || [...this.agents.values()].some((runtime) => runtime.freshForPendingDispatch)
+            || !this.allAgentsIdle())
+            return;
+        this.resendAfterLaunch.clear();
+        this.runDispatchOperation(undefined, this.retryPersistedDispatch(), "resume crosscheck");
+    }
+    async handleAgentIdle(agent, progressIdentity = this.takeCrosscheckTurnIdentity(agent)) {
+        this.settleCrosscheckSlot(agent, progressIdentity);
+        const runtime = this.agents.get(agent);
+        if (runtime?.freshForPendingDispatch
+            && !this.freshDispatchPreparations.has(agent)) {
+            this.freshDispatchPreparations.add(agent);
+            const snapshot = this.store.snapshot();
+            const generationId = snapshot.generation.id;
+            const dispatch = snapshot.generation.dispatch;
+            try {
+                if (dispatch?.agents[agent].status === "pending") {
+                    await this.store.update((state) => {
+                        if (state.generation.id === generationId
+                            && state.generation.dispatch?.token === dispatch.token
+                            && state.generation.dispatch.agents[agent].status === "pending") {
+                            state.generation.dispatch.agents[agent].baseline = runtime.monitor.lineBaseline;
+                            if (state.sessions[agent]) {
+                                delete state.sessions[agent].pendingDispatchBaselineReset;
+                            }
+                        }
+                    });
+                    if (this.isCurrentDispatch(generationId, dispatch.token)) {
+                        this.reconciliationBlocked.delete(agent);
+                        this.resendAfterLaunch.add(agent);
+                    }
+                }
+                runtime.freshForPendingDispatch = false;
+            }
+            finally {
+                this.freshDispatchPreparations.delete(agent);
+            }
+        }
+        const snapshot = this.store.snapshot();
+        const dispatch = snapshot.generation.dispatch;
+        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);
+            if (!this.isCurrentDispatch(snapshot.generation.id, dispatch.token)) {
+                this.maybeRetryPersistedDispatch();
+                return;
+            }
+            if (classification === "present") {
+                await this.markDispatchDelivered(agent, snapshot.generation.id, dispatch.token, "submitted");
+                if (this.isCurrentDispatchSide(agent, snapshot.generation.id, dispatch.token, "delivered"))
+                    this.reconciliationBlocked.delete(agent);
+                await this.finalizeDispatchIfComplete(snapshot.generation.id);
+            }
+            else if (classification === "absent") {
+                await this.markDispatchPending(agent, snapshot.generation.id, dispatch.token, "submitted");
+                if (this.isCurrentDispatchSide(agent, snapshot.generation.id, dispatch.token, "pending")) {
+                    this.reconciliationBlocked.delete(agent);
+                    this.resendAfterLaunch.add(agent);
+                }
+            }
+            else {
+                this.reconciliationBlocked.add(agent);
+                this.options.output.warn(`Cannot reconcile ${agentLabel(agent)} crosscheck; the prompt was not resent`);
+            }
+        }
+        this.maybeRetryPersistedDispatch();
+        await this.maybeSettleReconcileGate();
+    }
+    broadcastRowCount(cols, totalRows) {
+        const raw = this.broadcast.rowCount(cols);
+        return Math.max(1, Math.min(raw, Math.max(1, totalRows - MIN_AGENT_ROWS)));
+    }
+    paneDimensions(cols, totalRows) {
+        const agentAreaRows = Math.max(1, totalRows - this.broadcastRowCount(cols, totalRows));
+        const metrics = computeSplitMetrics({
+            cols,
+            rows: agentAreaRows,
+            collapseAt: SPLIT_COLLAPSE_AT_COLS,
+        });
+        const vtRows = Math.max(1, agentAreaRows - HEADER_ROWS);
+        if (metrics.collapsed) {
+            return {
+                "agent-1": { cols: metrics.leftWidth, rows: vtRows },
+                "agent-2": { cols: metrics.leftWidth, rows: vtRows },
+            };
+        }
+        return {
+            "agent-1": { cols: metrics.leftWidth, rows: vtRows },
+            "agent-2": { cols: metrics.rightWidth, rows: vtRows },
+        };
+    }
+    resizeSessions() {
+        const layout = this.options.host.getLayout();
+        const dimensions = this.paneDimensions(layout.columns, layout.childRows);
+        for (const agent of ["agent-1", "agent-2"]) {
+            const runtime = this.agents.get(agent);
+            const session = runtime?.session ?? this.launchingSessions.get(agent);
+            if (session)
+                session.resize(dimensions[agent].cols, dimensions[agent].rows);
+        }
+    }
+    refreshMouseModes() {
+        const modes = new Set([1000, 1006]);
+        for (const runtime of this.agents.values()) {
+            for (const mode of runtime.session.mouseModes())
+                modes.add(mode);
+        }
+        for (const session of this.launchingSessions.values()) {
+            for (const mode of session.mouseModes())
+                modes.add(mode);
+        }
+        this.options.host.setMouseModeSource(MOUSE_SOURCE, modes);
+    }
+    finish() {
+        if (this.finishing)
+            return;
+        this.finishing = true;
+        this.launchAbort?.abort(new Error("Crosscheck launch cancelled"));
+        this.dispatchAbort.abort(new Error("Crosscheck coordinator stopped"));
+        this.finishResolve?.({ kind: "crosscheck", interrupted: true });
+    }
+    fail(error) {
+        if (this.finishing)
+            return;
+        this.finishing = true;
+        this.launchAbort?.abort(error);
+        this.dispatchAbort.abort(error);
+        if (this.finishReject)
+            this.finishReject(error);
+        else
+            this.pendingFailure = error;
+    }
+    async dispose() {
+        this.finishing = true;
+        if (!this.dispatchAbort.signal.aborted) {
+            this.dispatchAbort.abort(new Error("Crosscheck coordinator disposed"));
+        }
+        if (this.resultTimer)
+            clearInterval(this.resultTimer);
+        this.resultTimer = undefined;
+        if (this.activityTimer)
+            clearInterval(this.activityTimer);
+        this.activityTimer = undefined;
+        if (this.transientFlash) {
+            clearTimeout(this.transientFlash.timer);
+            this.transientFlash = undefined;
+        }
+        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();
+        }
+        for (const session of this.launchingSessions.values())
+            session.close();
+        this.agents.clear();
+        this.launchingSessions.clear();
+    }
+    runDispatchOperation(agent, operation, action) {
+        const tracked = operation
+            .catch((err) => {
+            if (!this.finishing || !this.dispatchAbort.signal.aborted) {
+                this.warnDispatchFailure(agent, action, err);
+            }
+        })
+            .finally(() => {
+            this.dispatchOperations.delete(tracked);
+        });
+        this.dispatchOperations.add(tracked);
+    }
+    startActivityHeartbeat() {
+        if (!this.options.touchActivity)
+            return;
+        this.activityTimer = setInterval(() => {
+            this.trackActivity();
+        }, this.options.activityHeartbeatMs ?? ACTIVITY_HEARTBEAT_MS);
+    }
+    trackActivity() {
+        if (!this.options.touchActivity)
+            return;
+        const operation = this.options.touchActivity()
+            .catch((err) => {
+            this.options.output.warn(`Failed to refresh crosscheck session activity: ${err instanceof Error ? err.message : String(err)}`);
+        })
+            .finally(() => {
+            this.activityOperations.delete(operation);
+        });
+        this.activityOperations.add(operation);
+    }
+    warnDispatchFailure(agent, action, error) {
+        const target = agent ? ` for ${agentLabel(agent)}` : "";
+        const reason = error instanceof Error ? error.message : String(error);
+        this.options.output.warn(`Crosscheck ${action}${target} failed: ${reason}`);
+    }
+    async dumpRecords() {
+        const generation = this.store.snapshot().generation;
+        const committedTask = buildExecutorEffectiveTaskContext(generation.effectiveTask ?? this.options.task, generation.steerHistory);
+        return await Promise.all(["agent-1", "agent-2"].map(async (agent, index) => {
+            const config = this.options.configurations[agent];
+            const runtime = this.agents.get(agent);
+            const resultFile = generation.resultFiles[agent];
+            const outputs = {};
+            try {
+                outputs.result = {
+                    artifactName: `${agent}-result`,
+                    file: resultFile,
+                    bytes: await readFile(resultFile),
+                };
+            }
+            catch {
+                // Result may not exist while the executor is still working.
+            }
+            return {
+                seq: index,
+                stepId: agent,
+                role: "executor",
+                driver: config.driver,
+                phaseLabel: "Crosschecking...",
+                inputs: {
+                    task: { artifactName: TASK, text: committedTask },
+                },
+                outputs,
+                sessionFilePaths: runtime ? [runtime.session.identity.sessionFilePath] : [],
+                inFlight: true,
+                ...(runtime && { ptyTailSnapshot: runtime.session.ptyTail.snapshot() }),
+            };
+        }));
+    }
+}
+async function fileHasContent(path) {
+    try {
+        const file = await open(path, "r");
+        try {
+            const info = await file.stat();
+            if (!info.isFile() || info.size <= 0)
+                return false;
+            const probe = Buffer.allocUnsafe(1);
+            const { bytesRead } = await file.read(probe, 0, probe.length, 0);
+            return bytesRead > 0;
+        }
+        finally {
+            await file.close();
+        }
+    }
+    catch {
+        return false;
+    }
+}
+export function buildCrosscheckConfigurations(values) {
+    return {
+        "agent-1": {
+            driver: values.agent1,
+            model: values.agent1Model,
+            effort: values.agent1Effort,
+        },
+        "agent-2": {
+            driver: values.agent2,
+            model: values.agent2Model,
+            effort: values.agent2Effort,
+        },
+    };
+}
+function otherAgent(agent) {
+    return agent === "agent-1" ? "agent-2" : "agent-1";
+}
+function agentLabel(agent) {
+    return agent === "agent-1" ? "Agent 1" : "Agent 2";
+}
+// Re-exported for callers that only need mode availability without constructing a composer.
+export { availableBroadcastModes };
+//# sourceMappingURL=coordinator.js.map