poly-weaver 0.14.3 → 0.14.6

package/dist/crosscheck/coordinator.js

@@ -6,8 +6,10 @@ import { buildExecutorInitialPrompt, buildExecutorCrosscheckPrompt, buildExecuto
 import { sendInquiryQuestion } from "../offscreen/inquiry-sender.js";
 import { SessionTurnMonitor } from "../offscreen/session-turn-monitor.js";
 import { resolveProvider } from "../providers/registry.js";
+import { readSessionFileWithStatus } from "../session/reader.js";
 import { encodeKeysToBytes } from "../terminal/key-to-bytes.js";
-import { parseSgrMouseFrame, WHEEL_LINES_PER_EVENT, } from "../terminal/input-router.js";
+import { WHEEL_LINES_PER_EVENT, } from "../terminal/input-router.js";
+import { isUnmodifiedRightButtonGestureFrame, isUnmodifiedRightButtonPress, isUnmodifiedRightButtonRelease, parseSgrMouseFrame, } from "../terminal/sgr-mouse.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";
@@ -18,6 +20,8 @@ import { availableBroadcastModes, BroadcastComposer, } from "./broadcast-compose
 import { isControlKey, isEnterKey } from "./key-helpers.js";
 import { TASK } from "../flow/types.js";
 import { isArtifactViewerKey } from "../dump/hotkey.js";
+import { handleImagePasteIntent, PASTING_IMAGE_HINT, } from "../paste-image/intents.js";
+import { finalizeImageAttachments, hasImagePlaceholders, } from "../paste-image/persistence.js";
 const HEADER_ROWS = 1;
 const RESULT_POLL_MS = 300;
 const ACTIVITY_HEARTBEAT_MS = 60_000;
@@ -70,6 +74,8 @@ export class CrosscheckCoordinator {
     dispatching = false;
     broadcastSendActive = false;
     dispatchAbort = new AbortController();
+    operationFence = 0;
+    activeOperationAborts = new Set();
     dispatchOperations = new Set();
     activityOperations = new Set();
     resendAfterLaunch = new Set();
@@ -83,6 +89,7 @@ export class CrosscheckCoordinator {
     transientFlash;
     crosscheckProgress;
     selectionAgent;
+    focusedAgentRightButtonOwner;
     crosscheckTurnIdentities = new Map();
     constructor(options) {
         this.options = options;
@@ -101,6 +108,7 @@ export class CrosscheckCoordinator {
             this.detachUi = this.options.host.attachParentUi(this);
             const layout = this.options.host.getLayout();
             const dimensions = this.paneDimensions(layout.columns, layout.childRows);
+            await this.reconcilePersistedHistory();
             const persisted = this.store.snapshot();
             const launchAbort = new AbortController();
             this.launchAbort = launchAbort;
@@ -116,7 +124,8 @@ export class CrosscheckCoordinator {
                 try {
                     const config = this.options.configurations[agent];
                     const resultFile = persisted.generation.resultFiles[agent];
-                    const resultReady = await fileHasContent(resultFile);
+                    const resultState = persisted.generation.rewind?.[agent];
+                    const resultReady = resultState ? false : await fileHasContent(resultFile);
                     const prior = persisted.sessions[agent];
                     const resumeIdentity = prior?.driver === config.driver
                         ? {
@@ -141,13 +150,15 @@ export class CrosscheckCoordinator {
                         : 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 prompt = persisted.generation.rewind
+                        ? ""
+                        : 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,
@@ -176,6 +187,13 @@ export class CrosscheckCoordinator {
                     });
                     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();
@@ -200,9 +218,11 @@ export class CrosscheckCoordinator {
                         session,
                         monitor,
                         resultReady,
+                        resultState,
                         freshForPendingDispatch,
                         launchTurnExpected: session.resumed !== true || prompt.length > 0,
                     });
+                    monitor.startHistoryPolling();
                     await this.store.update((state) => {
                         const dispatch = state.generation.dispatch;
                         if (freshForPendingDispatch
@@ -221,6 +241,9 @@ export class CrosscheckCoordinator {
                             ...(freshForPendingDispatch && {
                                 pendingDispatchBaselineReset: true,
                             }),
+                            ...(persisted.sessions[agent]?.historySnapshot && {
+                                historySnapshot: persisted.sessions[agent].historySnapshot,
+                            }),
                         };
                     });
                     if (freshForPendingDispatch
@@ -257,7 +280,7 @@ export class CrosscheckCoordinator {
             }
             await this.reconcilePersistedDispatch();
             await this.maybeSettleReconcileGate();
-            this.broadcast.reconcileMode(this.currentReadiness());
+            this.broadcast.reconcileMode(this.currentReadiness(), this.currentGenerationPresentation());
             this.refreshMouseModes();
             this.resultTimer = setInterval(() => {
                 void this.refreshResults();
@@ -294,7 +317,7 @@ export class CrosscheckCoordinator {
             focusSwitchHint: this.focusSwitchHint(),
             version: `poly-weaver v${APP_VERSION}`,
             transient: this.currentTransientFlash(),
-        });
+        }, this.currentGenerationPresentation());
         const lines = [...top.lines.slice(0, agentAreaRows), ...broadcastPane.lines];
         while (lines.length < totalRows)
             lines.push("");
@@ -534,16 +557,22 @@ export class CrosscheckCoordinator {
             if (event.kind === "wheel" || event.kind === "raw") {
                 flush();
                 forwardedSide = this.focus === "broadcast" ? undefined : this.focus;
-                if (this.routeMouse(event))
+                const mouseFrame = event.kind === "raw" ? parseSgrMouseFrame(event) : undefined;
+                if (event.kind === "raw"
+                    && this.routeFocusedAgentRightButtonGesture(mouseFrame))
+                    continue;
+                if (this.routeMouse(event, mouseFrame))
                     continue;
             }
             if (this.focus === "broadcast") {
                 flush();
                 const submissionState = this.currentSubmissionState();
-                const outcome = this.broadcast.handleKey(event, this.currentReadiness(), submissionState);
+                const outcome = this.broadcast.handleKey(event, this.currentReadiness(), submissionState, 0, this.currentGenerationPresentation());
                 if (outcome === "submit") {
                     this.runDispatchOperation(undefined, this.submitBroadcast(), "broadcast send");
                 }
+                if (outcome === "clipboard-paste")
+                    this.requestBroadcastPaste();
                 if (outcome === "changed" || outcome === "mode-cycle")
                     broadcastChanged = true;
                 continue;
@@ -571,6 +600,12 @@ export class CrosscheckCoordinator {
         }
         return true;
     }
+    onClipboardPasteRequest() {
+        if (this.focus !== "broadcast")
+            return false;
+        this.requestBroadcastPaste();
+        return true;
+    }
     onResize() {
         this.resizeSessions();
     }
@@ -592,12 +627,14 @@ export class CrosscheckCoordinator {
         const focused = this.focus === agent;
         const config = runtime?.config ?? this.options.configurations[agent];
         const monitor = runtime?.monitor;
+        const resultSlot = runtime?.resultState
+            ?? (runtime?.resultReady ? "done" : undefined);
         const label = [
             config.driver,
             config.model,
             config.effort,
             monitor ? (monitor.isIdle ? "idle" : "working") : "starting",
-            runtime?.resultReady ? "done" : undefined,
+            resultSlot,
         ].filter(Boolean).join(" | ");
         const color = focused
             ? `${MUTED_YELLOW_BG}${TRUE_BLACK_FG}${bold}`
@@ -619,10 +656,10 @@ export class CrosscheckCoordinator {
             showCursor: focused && shouldShowVtCursor(session.vt),
         };
     }
-    routeMouse(event) {
+    routeMouse(event, frame) {
         const point = event.kind === "wheel"
             ? { column: event.column, row: event.row, button: undefined, final: undefined }
-            : parseSgrMouseFrame(event);
+            : frame;
         if (!point)
             return false;
         const layout = this.options.host.getLayout();
@@ -670,17 +707,62 @@ export class CrosscheckCoordinator {
         }
         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);
+        if (event.kind === "wheel") {
+            const bytes = encodeKeysToBytes([{ ...event, column: target.localColumn, row: localRow }], { wheelMode: "sgr" });
+            if (bytes.length > 0)
+                runtime.session.pty.write(bytes);
+            return true;
+        }
+        this.forwardMouseFrameToAgent(target.agent, point);
         return true;
     }
+    routeFocusedAgentRightButtonGesture(frame) {
+        if (!frame)
+            return false;
+        const owner = this.focusedAgentRightButtonOwner;
+        if (owner && isUnmodifiedRightButtonGestureFrame(frame)) {
+            this.forwardMouseFrameToAgent(owner, frame);
+            if (isUnmodifiedRightButtonRelease(frame)) {
+                this.focusedAgentRightButtonOwner = undefined;
+            }
+            return true;
+        }
+        if (this.focus === "broadcast" || !isUnmodifiedRightButtonPress(frame)) {
+            return false;
+        }
+        this.focusedAgentRightButtonOwner = this.focus;
+        this.forwardMouseFrameToAgent(this.focus, frame);
+        return true;
+    }
+    forwardMouseFrameToAgent(agent, frame) {
+        const runtime = this.agents.get(agent);
+        if (!runtime)
+            return;
+        if (!runtime.session.hasMouseReporting() && !runtime.session.vt.isAlternate)
+            return;
+        const point = this.agentPaneMousePoint(agent, frame);
+        runtime.session.pty.write(Buffer.from(`\x1b[<${frame.button};${point.localColumn};${point.localRow}${frame.final}`, "ascii"));
+    }
+    agentPaneMousePoint(agent, point) {
+        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,
+        });
+        const paneStart = metrics.collapsed || agent === "agent-1"
+            ? 1
+            : metrics.leftWidth + 2;
+        const paneWidth = metrics.collapsed || agent === "agent-1"
+            ? metrics.leftWidth
+            : metrics.rightWidth;
+        const localColumn = Math.min(paneWidth, Math.max(1, point.column - paneStart + 1));
+        const maxLocalRow = Math.max(1, agentAreaRows - HEADER_ROWS);
+        const localRow = Math.min(maxLocalRow, Math.max(1, point.row - HEADER_ROWS));
+        return { localColumn, localRow };
+    }
     agentAtColumn(column) {
         const layout = this.options.host.getLayout();
         const totalRows = layout.childRows;
@@ -709,6 +791,11 @@ export class CrosscheckCoordinator {
             agent2Ready: !!this.agents.get("agent-2")?.resultReady,
         };
     }
+    currentGenerationPresentation() {
+        return this.store?.generationInvalidated()
+            ? { kind: "rewound" }
+            : { kind: "active" };
+    }
     currentResultFile(agent) {
         return this.store.snapshot().generation.resultFiles[agent];
     }
@@ -718,8 +805,63 @@ export class CrosscheckCoordinator {
         const generation = this.store.snapshot().generation;
         return generation.id === 0 ? this.options.task : generation.prompt;
     }
+    async reconcilePersistedHistory() {
+        const snapshot = this.store.snapshot();
+        await Promise.all(["agent-1", "agent-2"].map(async (agent) => {
+            const session = snapshot.sessions[agent];
+            const config = this.options.configurations[agent];
+            if (!session || session.driver !== config.driver || !session.historySnapshot) {
+                return;
+            }
+            const provider = resolveProvider(config.driver);
+            const buildSnapshot = provider.fork.sessionHistorySnapshot;
+            const compare = provider.fork.compareSessionHistory;
+            if (!buildSnapshot || !compare)
+                return;
+            try {
+                const { lines, malformed } = await readSessionFileWithStatus(session.sessionFilePath);
+                if (malformed)
+                    return;
+                const current = buildSnapshot(lines);
+                if (!current)
+                    return;
+                if (compare(session.historySnapshot, current)) {
+                    await this.invalidateGenerationForRewind(agent, current);
+                }
+                else {
+                    await this.store.updateSessionHistory(agent, current);
+                }
+            }
+            catch {
+                // Unreadable history is indeterminate; it is never proof of rewind.
+            }
+        }));
+    }
+    async invalidateGenerationForRewind(agent, snapshot) {
+        this.abortActiveDispatchOperations(new Error("Crosscheck generation invalidated by session rewind"));
+        await this.store.invalidateGenerationForRewind(agent, snapshot);
+        const rewind = this.store.generationRewindState();
+        for (const side of ["agent-1", "agent-2"]) {
+            const runtime = this.agents.get(side);
+            if (!runtime)
+                continue;
+            runtime.resultReady = false;
+            runtime.resultState = rewind?.[side];
+            runtime.freshForPendingDispatch = false;
+        }
+        this.crosscheckProgress = undefined;
+        this.crosscheckTurnIdentities.clear();
+        this.resendAfterLaunch.clear();
+        this.reconciliationBlocked.clear();
+        this.freshDispatchPreparations.clear();
+        this.broadcast.reconcileMode(this.currentReadiness(), this.currentGenerationPresentation());
+        this.refreshStatusHint();
+        this.options.host.scheduleParentUiRender();
+    }
     currentCrosscheckStatus() {
         const progress = this.crosscheckProgress;
+        if (this.store?.generationInvalidated())
+            return { kind: "unavailable" };
         if (progress
             && this.store
             && this.store.generationId() === progress.generationId) {
@@ -747,12 +889,31 @@ export class CrosscheckCoordinator {
             return "broadcasting";
         return "ready";
     }
+    requestBroadcastPaste() {
+        void handleImagePasteIntent(this.broadcast.attachments, () => {
+            this.flashTransient(PASTING_IMAGE_HINT, 3000);
+        }).then((outcome) => {
+            if (outcome.inserted !== undefined) {
+                this.broadcast.applyInsertedText(outcome.inserted);
+                this.resizeSessions();
+            }
+            if (outcome.hint)
+                this.flashTransient(outcome.hint, 3000);
+            else
+                this.options.host.scheduleParentUiRender();
+            this.refreshStatusHint();
+        }).catch((err) => {
+            this.flashTransient(err instanceof Error ? err.message : String(err), 3000);
+        });
+    }
     isArmed() {
         return this.isCrosscheckArmed() || this.isReconcileArmed();
     }
     isCrosscheckArmed() {
         if (!this.store || !this.sessionsReady)
             return false;
+        if (this.store.generationInvalidated())
+            return false;
         if (this.dispatching || this.store.generationConsumed() || this.store.hasDispatch()) {
             return false;
         }
@@ -761,6 +922,8 @@ export class CrosscheckCoordinator {
     isReconcileArmed() {
         if (!this.store || !this.sessionsReady)
             return false;
+        if (this.store.generationInvalidated())
+            return false;
         if (this.dispatching
             || !this.store.generationConsumed()
             || this.store.hasDispatch()
@@ -898,9 +1061,11 @@ export class CrosscheckCoordinator {
         const attemptId = this.beginCrosscheckProgress(generationId, token, phase);
         const agents = ["agent-1", "agent-2"];
         try {
-            await this.withDispatchLifecycle(agents, async () => {
+            await this.withDispatchLifecycle(agents, async (operation) => {
                 await this.store.update((state) => {
-                    if (state.generation.id !== generationId)
+                    if (state.generation.id !== generationId
+                        || state.generation.rewind
+                        || !this.isOperationCurrent(operation))
                         return;
                     state.generation.reconcileAllowed = false;
                     state.generation.reconcileSettled = false;
@@ -920,12 +1085,16 @@ export class CrosscheckCoordinator {
                         },
                     };
                 });
-                const results = await Promise.allSettled(agents.map((agent) => this.sendDispatchAgent(agent, generationId, attemptId)));
+                if (!this.isCurrentGenerationOperation(generationId, operation))
+                    return;
+                const results = await Promise.allSettled(agents.map((agent) => this.sendDispatchAgent(agent, generationId, attemptId, operation)));
                 for (const [index, result] of results.entries()) {
                     if (result.status === "rejected") {
                         this.warnDispatchFailure(agents[index], "send", result.reason);
                     }
                 }
+                if (!this.isCurrentGenerationOperation(generationId, operation))
+                    return;
                 await this.finalizeDispatchIfComplete(generationId);
             });
         }
@@ -933,12 +1102,12 @@ export class CrosscheckCoordinator {
             this.settleUnsubmittedCrosscheckSlots(attemptId);
         }
     }
-    async sendDispatchAgent(agent, generationId, progressAttemptId) {
+    async sendDispatchAgent(agent, generationId, progressAttemptId, operation = this.currentDispatchOperationContext()) {
         if (this.reconciliationBlocked.has(agent))
             return;
-        const state = this.store.snapshot();
-        if (state.generation.id !== generationId)
+        if (!this.isCurrentGenerationOperation(generationId, operation))
             return;
+        const state = this.store.snapshot();
         const dispatch = state.generation.dispatch;
         if (!dispatch || dispatch.agents[agent].status !== "pending")
             return;
@@ -950,9 +1119,11 @@ export class CrosscheckCoordinator {
         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,
+                signal: operation.signal,
                 composer: provider.composer,
                 onSubmitted: () => {
+                    if (!this.isCurrentGenerationOperation(generationId, operation))
+                        return;
                     submitted = true;
                     if (progressAttemptId) {
                         this.markCrosscheckSlotSubmitted(agent, generationId, dispatch.token, progressAttemptId);
@@ -964,13 +1135,17 @@ export class CrosscheckCoordinator {
         finally {
             releaseInputLock();
         }
-        if (!submitted)
+        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);
+        if (!this.isCurrentGenerationOperation(generationId, operation))
+            return;
         if (classification === "present") {
             await this.markDispatchDelivered(agent, generationId, dispatch.token, "submitted");
         }
+        if (!this.isCurrentGenerationOperation(generationId, operation))
+            return;
         await this.finalizeDispatchIfComplete(generationId);
     }
     buildDispatchPrompt(agent, generationId, phase, round) {
@@ -1020,9 +1195,9 @@ export class CrosscheckCoordinator {
         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 () => {
+            await this.withDispatchLifecycle(lockedAgents, async (operation) => {
                 const state = this.store.snapshot();
-                if (state.generation.id !== generationId)
+                if (!this.isCurrentGenerationOperation(generationId, operation))
                     return;
                 const dispatch = state.generation.dispatch;
                 if (!dispatch || (state.generation.consumed && dispatch.phase === "crosscheck")) {
@@ -1036,15 +1211,17 @@ export class CrosscheckCoordinator {
                         continue;
                     const current = await this.reconcileDispatchSide(agent, generationId, dispatch, expectedStatus, async () => {
                         try {
-                            await this.sendDispatchAgent(agent, generationId, attemptId);
+                            await this.sendDispatchAgent(agent, generationId, attemptId, operation);
                         }
                         catch (err) {
                             this.warnDispatchFailure(agent, "retry", err);
                         }
-                    });
+                    }, operation);
                     if (!current)
                         return;
                 }
+                if (!this.isCurrentGenerationOperation(generationId, operation))
+                    return;
                 await this.finalizeDispatchIfComplete(generationId);
             });
         }
@@ -1052,7 +1229,9 @@ export class CrosscheckCoordinator {
             this.settleUnsubmittedCrosscheckSlots(attemptId);
         }
     }
-    async reconcileDispatchSide(agent, generationId, dispatch, expectedStatus, onAbsent) {
+    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);
@@ -1077,6 +1256,8 @@ export class CrosscheckCoordinator {
         }
         const classification = await resolveProvider(target.driver)
             .live.classifyDispatchDelivery(target.sessionFilePath, dispatch.agents[agent].baseline);
+        if (!this.isCurrentGenerationOperation(generationId, operation))
+            return false;
         if (!this.isCurrentDispatch(generationId, dispatch.token))
             return false;
         if (!this.isCurrentDispatchSide(agent, generationId, dispatch.token, expectedStatus))
@@ -1107,14 +1288,16 @@ export class CrosscheckCoordinator {
         return true;
     }
     async withDispatchLifecycle(lockedAgents, dispatch) {
+        const operation = this.beginDispatchOperation();
         this.dispatching = true;
         this.refreshStatusHint();
         this.options.host.scheduleParentUiRender();
         const releaseInputLocks = lockedAgents.map((agent) => this.lockAutomatedInput(agent));
         try {
-            await dispatch();
+            await dispatch(operation);
         }
         finally {
+            operation.release();
             for (const release of releaseInputLocks)
                 release();
             this.dispatching = false;
@@ -1157,28 +1340,40 @@ export class CrosscheckCoordinator {
     }
     async settleReconcileGate(generationId) {
         const generation = this.store.snapshot().generation;
+        const round = generation.reconcileRound;
         if (generation.id !== generationId
             || !generation.reconcilePendingSettlement
-            || generation.dispatch)
+            || generation.dispatch
+            || !this.allAgentsIdle())
             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)
+        const afterRead = this.store.snapshot().generation;
+        if (afterRead.id !== generationId
+            || afterRead.reconcileRound !== round
+            || !afterRead.reconcilePendingSettlement
+            || afterRead.dispatch
+            || !this.allAgentsIdle())
             return;
         if (!agent1 || !agent2) {
+            let markedMissing = false;
             await this.store.update((state) => {
                 if (state.generation.id !== generationId
+                    || state.generation.reconcileRound !== round
                     || !state.generation.reconcilePendingSettlement
-                    || state.generation.dispatch)
+                    || state.generation.dispatch
+                    || !this.allAgentsIdle())
                     return;
                 state.generation.reconcileJsonMissing = true;
                 state.generation.reconcileAllowed = false;
                 state.generation.reconcileSettled = false;
                 state.generation.reconcilePendingSettlement = false;
+                markedMissing = true;
             });
+            if (!markedMissing)
+                return;
             this.options.output.warn("Crosscheck review JSON is missing or malformed; Ctrl+X Reconcile is unavailable.");
             this.refreshStatusHint();
             this.options.host.scheduleParentUiRender();
@@ -1187,16 +1382,22 @@ export class CrosscheckCoordinator {
         const reconcileAllowed = round === 0
             ? true
             : agent1.rejected.length > 0 || agent2.rejected.length > 0;
+        let settled = false;
         await this.store.update((state) => {
             if (state.generation.id !== generationId
+                || state.generation.reconcileRound !== round
                 || !state.generation.reconcilePendingSettlement
-                || state.generation.dispatch)
+                || state.generation.dispatch
+                || !this.allAgentsIdle())
                 return;
             state.generation.reconcileJsonMissing = false;
             state.generation.reconcileAllowed = reconcileAllowed;
             state.generation.reconcileSettled = true;
             state.generation.reconcilePendingSettlement = false;
+            settled = true;
         });
+        if (!settled)
+            return;
         this.refreshStatusHint();
         this.options.host.scheduleParentUiRender();
     }
@@ -1209,6 +1410,7 @@ export class CrosscheckCoordinator {
     transitionDispatchStatus(agent, generationId, dispatchToken, expectedStatus, nextStatus) {
         return this.store.update((state) => {
             if (state.generation.id === generationId
+                && !state.generation.rewind
                 && state.generation.dispatch?.token === dispatchToken
                 && state.generation.dispatch.agents[agent].status === expectedStatus) {
                 state.generation.dispatch.agents[agent].status = nextStatus;
@@ -1236,24 +1438,42 @@ export class CrosscheckCoordinator {
             && ["agent-1", "agent-2"].some((agent) => this.hasPendingCrosscheck(agent)))
             return;
         const submission = this.broadcast.beginSubmission();
+        let finalizedText;
         const agents = ["agent-1", "agent-2"];
         let initiated = false;
         this.broadcastSendActive = true;
         this.refreshStatusHint();
         this.options.host.scheduleParentUiRender();
         try {
-            await this.withDispatchLifecycle(agents, async () => {
+            await this.withDispatchLifecycle(agents, async (operation) => {
                 for (const agent of agents) {
                     if (!this.agents.has(agent)) {
                         throw new Error(`${agentLabel(agent)} is not ready for Broadcast`);
                     }
                 }
+                if (hasImagePlaceholders(text)) {
+                    try {
+                        finalizedText = await finalizeImageAttachments(text, this.broadcast.attachments, this.options.persistentDir);
+                    }
+                    catch (err) {
+                        this.flashTransient(err instanceof Error ? err.message : String(err), 3000);
+                        throw err;
+                    }
+                }
+                else {
+                    finalizedText = text;
+                }
+                if (!this.isOperationCurrent(operation))
+                    return;
                 if (mode === "steer" || mode === "follow-up") {
                     const deliverySubmitCounts = await this.captureGenerationDeliveryCounts();
-                    await this.store.startGeneration(mode, text, deliverySubmitCounts);
+                    if (!this.isOperationCurrent(operation))
+                        return;
+                    await this.store.startGeneration(mode, finalizedText, deliverySubmitCounts);
                     this.crosscheckProgress = undefined;
                     for (const runtime of this.agents.values()) {
                         runtime.resultReady = false;
+                        runtime.resultState = undefined;
                         runtime.freshForPendingDispatch = false;
                     }
                     this.resendAfterLaunch.clear();
@@ -1265,12 +1485,14 @@ export class CrosscheckCoordinator {
                 const generationKind = mode === "steer" || mode === "follow-up"
                     ? mode
                     : undefined;
-                const sends = agents.map((agent) => this.sendBroadcastAgent(agent, text, generationId, generationKind));
+                const sends = agents.map((agent) => this.sendBroadcastAgent(agent, finalizedText, generationId, generationKind, operation));
                 initiated = true;
                 this.broadcast.completeSubmission(submission);
                 this.resizeSessions();
                 this.options.host.scheduleParentUiRender();
                 const results = await Promise.allSettled(sends);
+                if (!this.isOperationCurrent(operation))
+                    return;
                 for (const [index, result] of results.entries()) {
                     if (result.status === "rejected") {
                         this.warnDispatchFailure(agents[index], "broadcast send", result.reason);
@@ -1294,19 +1516,18 @@ export class CrosscheckCoordinator {
             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)];
-        }));
+        const entries = await Promise.all(runtimes.map(async ([agent, runtime]) => [agent, await runtime.monitor.expectedSubmitCountFromSession()]));
         return Object.fromEntries(entries);
     }
-    async sendBroadcastAgent(agent, text, generationId, generationKind) {
+    async sendBroadcastAgent(agent, text, generationId, generationKind, operation = this.currentDispatchOperationContext()) {
         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)
+        const conversational = generationKind === undefined;
+        if (!this.isCurrentGenerationOperation(generationId, operation, { allowRewound: conversational })) {
             return;
+        }
+        const generation = this.store.snapshot().generation;
         const prompt = generationKind === "steer"
             ? buildExecutorSteerPrompt(text, generation.resultFiles[agent])
             : generationKind === "follow-up"
@@ -1316,12 +1537,19 @@ export class CrosscheckCoordinator {
         const releaseInputLock = this.lockAutomatedInput(agent);
         try {
             if (generationKind && provider.cancelSequence) {
-                await sendCancelSequence(runtime.session.pty, provider.cancelSequence, this.dispatchAbort.signal, runtime.monitor.isIdle);
+                await sendCancelSequence(runtime.session.pty, provider.cancelSequence, operation.signal, runtime.monitor.isIdle);
+            }
+            if (!this.isCurrentGenerationOperation(generationId, operation, { allowRewound: conversational })) {
+                return;
             }
             await (this.options.sendInquiry ?? sendInquiryQuestion)(runtime.session, prompt, {
-                signal: this.dispatchAbort.signal,
+                signal: operation.signal,
                 composer: provider.composer,
-                onSubmitted: () => runtime.monitor.beginTurn(),
+                onSubmitted: () => {
+                    if (!this.isCurrentGenerationOperation(generationId, operation, { allowRewound: conversational }))
+                        return;
+                    runtime.monitor.beginTurn();
+                },
                 ...(generationKind ? { escapeBeforePaste: true } : {}),
             });
         }
@@ -1342,6 +1570,8 @@ export class CrosscheckCoordinator {
     async performResultRefresh() {
         let changed = false;
         const generation = this.store.snapshot().generation;
+        if (generation.rewind)
+            return;
         const readiness = await Promise.all(["agent-1", "agent-2"].map(async (agent) => ({
             agent,
             ready: await fileHasContent(generation.resultFiles[agent]),
@@ -1357,7 +1587,7 @@ export class CrosscheckCoordinator {
             }
         }
         if (changed) {
-            this.broadcast.reconcileMode(this.currentReadiness());
+            this.broadcast.reconcileMode(this.currentReadiness(), this.currentGenerationPresentation());
             this.refreshStatusHint();
             this.options.host.scheduleParentUiRender();
             this.maybeRetryPersistedDispatch();
@@ -1539,6 +1769,7 @@ export class CrosscheckCoordinator {
         this.finishing = true;
         this.launchAbort?.abort(new Error("Crosscheck launch cancelled"));
         this.dispatchAbort.abort(new Error("Crosscheck coordinator stopped"));
+        this.abortActiveDispatchOperations(new Error("Crosscheck coordinator stopped"));
         this.finishResolve?.({ kind: "crosscheck", interrupted: true });
     }
     fail(error) {
@@ -1547,6 +1778,7 @@ export class CrosscheckCoordinator {
         this.finishing = true;
         this.launchAbort?.abort(error);
         this.dispatchAbort.abort(error);
+        this.abortActiveDispatchOperations(error);
         if (this.finishReject)
             this.finishReject(error);
         else
@@ -1557,6 +1789,7 @@ export class CrosscheckCoordinator {
         if (!this.dispatchAbort.signal.aborted) {
             this.dispatchAbort.abort(new Error("Crosscheck coordinator disposed"));
         }
+        this.abortActiveDispatchOperations(new Error("Crosscheck coordinator disposed"));
         if (this.resultTimer)
             clearInterval(this.resultTimer);
         this.resultTimer = undefined;
@@ -1594,6 +1827,55 @@ export class CrosscheckCoordinator {
         });
         this.dispatchOperations.add(tracked);
     }
+    beginDispatchOperation() {
+        const controller = new AbortController();
+        const abortFromRoot = () => {
+            controller.abort(this.dispatchAbort.signal.reason
+                ?? new Error("Crosscheck dispatch cancelled"));
+        };
+        if (this.dispatchAbort.signal.aborted) {
+            abortFromRoot();
+        }
+        else {
+            this.dispatchAbort.signal.addEventListener("abort", abortFromRoot, { once: true });
+        }
+        this.activeOperationAborts.add(controller);
+        let released = false;
+        return {
+            fence: this.operationFence,
+            signal: controller.signal,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.dispatchAbort.signal.removeEventListener("abort", abortFromRoot);
+                this.activeOperationAborts.delete(controller);
+            },
+        };
+    }
+    currentDispatchOperationContext() {
+        return {
+            fence: this.operationFence,
+            signal: this.dispatchAbort.signal,
+        };
+    }
+    isOperationCurrent(operation) {
+        return operation.fence === this.operationFence
+            && !operation.signal.aborted
+            && !this.dispatchAbort.signal.aborted;
+    }
+    isCurrentGenerationOperation(generationId, operation, options = {}) {
+        if (!this.isOperationCurrent(operation))
+            return false;
+        return this.store.isGenerationCurrent(generationId, options);
+    }
+    abortActiveDispatchOperations(reason) {
+        this.operationFence++;
+        for (const controller of this.activeOperationAborts) {
+            controller.abort(reason);
+        }
+        this.activeOperationAborts.clear();
+    }
     startActivityHeartbeat() {
         if (!this.options.touchActivity)
             return;