poly-weaver 0.15.2 → 1.0.0

package/dist/offscreen/controller.js

@@ -3,14 +3,15 @@ import { builtinStrategies, resolveProvider } from "../providers/registry.js";
 import { Fork } from "./fork.js";
 import { foldAltMetaKeys, isPrimaryIssueKey, isPrimaryShowKey, isSecondaryIssueKey, isSecondaryShowKey, isSummarizeKey, } from "./keys.js";
 import { InquiryPaneController } from "./inquiry-pane.js";
+import { StartingInquiryPane } from "./starting-pane.js";
 import { ArtifactPaneController } from "./artifact-pane.js";
 import { registerOffscreenDisposer } from "./registry.js";
 import { SplitInquiryCoordinator } from "./split-inquiry.js";
 import { SPLIT_COLLAPSE_AT_COLS, } from "../user/split-surface.js";
 import { sendInquiryQuestion } from "./inquiry-sender.js";
-import { readSessionFile, readSessionFileWithStatus, } from "../session/reader.js";
+import { readSessionFileWithStatus, } from "../session/reader.js";
 import { forkFileSubmitFloor, locateForkSessionFile, submitCount, } from "./fork-busy.js";
-import { SessionTurnMonitor, } from "./session-turn-monitor.js";
+import { SessionTurnMonitor, SessionTurnReceipt, DEFAULT_TURN_ATTEMPT_TIMEOUT_MS, } from "./session-turn-monitor.js";
 import { abortableSleep } from "../util/abortable-sleep.js";
 const OFFSCREEN_MOUSE_SOURCE = "offscreen";
 const DEFAULT_TURN_POLL_MS = 500;
@@ -19,6 +20,7 @@ export class OffscreenController {
     host;
     workdir;
     inquiry;
+    observerRuns;
     slots = new Map();
     artifactConfigs;
     turnPollMs;
@@ -26,6 +28,9 @@ export class OffscreenController {
     tracksTurns;
     forks = new Map();
     pending = new Map();
+    pendingForks = new Map();
+    pendingQuestions = new Map();
+    launchAbort = new AbortController();
     sendPending = new Set();
     turnInProgress = new Set();
     turnMonitors = new Map();
@@ -36,36 +41,40 @@ export class OffscreenController {
     forkBaselines = new Map();
     forkLocateAborts = new Map();
     forkSubmitFloors = new Map();
-    pendingTurnGenerations = new Map();
-    pendingTurnAttempts = new Map();
+    pendingTurns = new Map();
+    pendingAttemptTimers = new Map();
     forkSubmitFloorReads = new Map();
     forkLocateWarned = new Set();
     activeArtifactIndexes = new Map();
+    artifactPanes = new Map();
     unregister;
     split;
     shown;
     disposed = false;
-    constructor(host, workdir, slots, artifactConfigs = {}, inquiry) {
+    disposal;
+    constructor(host, workdir, slots, artifactConfigs = {}, inquiry, observerRuns) {
         this.host = host;
         this.workdir = workdir;
         this.inquiry = inquiry;
+        this.observerRuns = observerRuns;
         for (const slot of slots) {
             this.slots.set(slot.binding, slot);
         }
         // Snapshot the configs so later caller mutation can't reach the controller.
         this.artifactConfigs = { ...artifactConfigs };
         this.turnPollMs = inquiry?.turnPollMs ?? DEFAULT_TURN_POLL_MS;
-        this.turnAttemptTimeoutMs = inquiry?.turnAttemptTimeoutMs;
+        this.turnAttemptTimeoutMs = inquiry?.turnAttemptTimeoutMs ?? DEFAULT_TURN_ATTEMPT_TIMEOUT_MS;
         this.tracksTurns =
             inquiry !== undefined || slots.some((slot) => slot.summarizePrompt !== undefined);
         this.unregister = registerOffscreenDisposer(() => this.dispose());
     }
     isIssueInquiryReady(binding) {
-        return !this.sendPending.has(binding) && !this.turnInProgress.has(binding);
+        return !this.sendPending.has(binding) && !this.turnInProgress.has(binding)
+            && !this.sendLocks.has(binding);
     }
     selectionDelegate() {
         return {
-            fork: this.shown ? this.forks.get(this.shown) : undefined,
+            fork: this.shown ? this.presentedFork(this.shown) : undefined,
             layout: this.host.getLayout(),
             coordinator: this.activeCoordinator(),
         };
@@ -73,15 +82,16 @@ export class OffscreenController {
     wrap(base) {
         return {
             getSurface: () => {
-                const fork = this.shown ? this.forks.get(this.shown) : undefined;
-                if (!fork)
+                const fork = this.shown ? this.presentedFork(this.shown) : undefined;
+                if (!this.shown)
                     return base.getSurface();
                 const layout = this.host.getLayout();
                 const coordinator = this.activeCoordinator();
                 if (coordinator) {
                     return coordinator.getSurface(layout.columns, layout.childRows);
                 }
-                return new InquiryPaneController(fork).render(layout.columns, layout.childRows);
+                return (fork ? new InquiryPaneController(fork, this.forks.has(this.shown)) : this.startingPane(this.shown))
+                    .render(layout.columns, layout.childRows);
             },
             selectionRegionAt: (column, row) => {
                 const { fork, layout, coordinator } = this.selectionDelegate();
@@ -89,7 +99,7 @@ export class OffscreenController {
                     return coordinator.selectionRegionAt(column, row, layout.columns, layout.childRows);
                 }
                 if (!fork)
-                    return base.selectionRegionAt?.(column, row);
+                    return this.shown ? null : base.selectionRegionAt?.(column, row);
                 if (row < 2 || row > layout.childRows)
                     return null;
                 return fork.vt.isAlternate === true
@@ -102,7 +112,7 @@ export class OffscreenController {
                     return coordinator.selectionTargetAt(column, row, layout.columns, layout.childRows);
                 }
                 if (!fork)
-                    return base.selectionTargetAt?.(column, row) ?? null;
+                    return this.shown ? null : base.selectionTargetAt?.(column, row) ?? null;
                 if (fork.vt.isAlternate === true)
                     return null;
                 if (column < 1 || column > layout.columns || row < 2 || row > layout.childRows)
@@ -115,7 +125,7 @@ export class OffscreenController {
                     return coordinator.scrollSelectableSurfaceAt(column, row, direction, layout.columns, layout.childRows);
                 }
                 if (!fork || fork.vt.isAlternate === true) {
-                    return base.scrollSelectableSurfaceAt?.(column, row, direction) ?? 0;
+                    return this.shown ? 0 : base.scrollSelectableSurfaceAt?.(column, row, direction) ?? 0;
                 }
                 if (column < 1 || column > layout.columns)
                     return 0;
@@ -133,7 +143,7 @@ export class OffscreenController {
                     return placement ? { region: placement.region, vt: fork.vt } : undefined;
                 }
                 if (!fork || fork.vt.isAlternate === true || layout.childRows < 2) {
-                    return base.forkSelectionPlacement?.();
+                    return this.shown ? undefined : base.forkSelectionPlacement?.();
                 }
                 return {
                     region: { rowStart: 2, rowEnd: layout.childRows, colStart: 1, colEnd: layout.columns },
@@ -145,7 +155,7 @@ export class OffscreenController {
                 if (coordinator) {
                     return coordinator.artifactPlacementAt(column, row, layout.columns, layout.childRows);
                 }
-                if (fork)
+                if (this.shown)
                     return undefined;
                 return base.docSurfaceSelectionPlacementAt?.(column, row);
             },
@@ -155,7 +165,7 @@ export class OffscreenController {
                     const placement = coordinator.artifactPlacement(layout.columns, layout.childRows);
                     return placement ? [placement] : [];
                 }
-                if (fork)
+                if (this.shown)
                     return [];
                 return base.docSurfaceSelectionPlacements?.() ?? [];
             },
@@ -164,11 +174,13 @@ export class OffscreenController {
                 if (coordinator) {
                     return coordinator.artifactPlacement(layout.columns, layout.childRows);
                 }
-                if (fork)
+                if (this.shown)
                     return undefined;
                 return base.artifactSelectionPlacement?.();
             },
             onEvents: (keys) => {
+                if (this.disposed)
+                    return true;
                 const events = this.inquiry ? foldAltMetaKeys(keys) : keys;
                 if (keys.some(isSummarizeKey) && this.canSummarize("primary")) {
                     return this.summarize("primary");
@@ -200,41 +212,60 @@ export class OffscreenController {
             onResize: (cols, rows) => {
                 if (this.disposed)
                     return;
-                const fork = this.shown ? this.forks.get(this.shown) : undefined;
-                if (fork && this.shown)
+                const fork = this.shown ? this.presentedFork(this.shown) : undefined;
+                if (this.shown)
                     this.configurePresentation(this.shown, fork, cols, rows);
                 this.updateForkState();
             },
         };
     }
     dispose() {
-        if (this.disposed)
-            return;
+        if (this.disposal)
+            return this.disposal;
         this.disposed = true;
+        this.launchAbort.abort();
         this.unregister();
         for (const binding of Array.from(this.sendControllers.keys())) {
             this.abortIssueSend(binding);
         }
         this.clearForkSessionWatchers();
-        for (const fork of this.forks.values()) {
-            fork.kill();
-        }
+        const releases = [...this.forks.values(), ...this.pendingForks.values()].map((fork) => fork.kill());
+        const pending = Array.from(this.pending.values());
         this.forks.clear();
         this.pending.clear();
+        this.pendingForks.clear();
+        this.pendingQuestions.clear();
+        this.artifactPanes.clear();
         this.sendPending.clear();
         this.sendLocks.clear();
         this.shown = undefined;
         this.clearSplitCoordinator();
         this.host.clearMouseModeSource(OFFSCREEN_MOUSE_SOURCE);
         this.updateForkState();
+        return this.disposal = Promise.all([...releases, ...pending]).then(() => { });
     }
     handleForkEvents(keys) {
         const binding = this.shown;
         const fork = binding ? this.forks.get(binding) : undefined;
         if (!fork) {
-            this.shown = undefined;
-            this.clearSplitCoordinator();
-            this.updateForkState();
+            if (!binding)
+                return true;
+            if (keys.some((key) => key.kind === "control" && key.byte === 0x03)) {
+                this.hideFork(this.pendingForks.get(binding));
+                return true;
+            }
+            for (const key of keys) {
+                if (isArtifactViewerKey(key) && this.cycleCompanionArtifact(binding))
+                    continue;
+                const shortcut = this.inquiry ? inquiryShortcutForKey(key) : undefined;
+                if (shortcut?.kind === "issue" && shortcut.binding === binding) {
+                    this.openInquiry(shortcut);
+                }
+            }
+            const layout = this.host.getLayout();
+            const result = this.activeCoordinator()?.handleArtifactScroll(keys, layout.columns, layout.childRows);
+            if (result)
+                this.applyPaneResult(undefined, result);
             return true;
         }
         if (binding && this.sendLocks.has(binding)) {
@@ -285,16 +316,16 @@ export class OffscreenController {
             return true;
         if (routed.length === 0)
             return true;
-        const coordinator = this.activeCoordinator();
-        const layout = this.host.getLayout();
-        const result = coordinator
-            ? coordinator.handleEvents(routed, layout.columns, layout.childRows)
-            : new InquiryPaneController(fork).handleKeys(routed);
         if (this.tracksTurns && binding) {
             for (let submission = 0; submission < manualSubmissions; submission++) {
                 this.beginTurnAttempt(binding);
             }
         }
+        const coordinator = this.activeCoordinator();
+        const layout = this.host.getLayout();
+        const result = coordinator
+            ? coordinator.handleEvents(routed, layout.columns, layout.childRows)
+            : new InquiryPaneController(fork).handleKeys(routed);
         this.applyPaneResult(fork, result);
         return true;
     }
@@ -334,14 +365,17 @@ export class OffscreenController {
             this.hideFork(fork);
         }
     }
+    presentedFork(binding) {
+        return this.forks.get(binding) ?? this.pendingForks.get(binding);
+    }
     hideFork(fork) {
         if (this.shown)
             this.abortIssueSend(this.shown);
         if (this.activeCoordinator()) {
             const layout = this.host.getLayout();
-            fork.resize(layout.columns, layout.childRows);
+            fork?.resize(layout.columns, layout.childRows);
         }
-        fork.setVisible(false);
+        fork?.setVisible(false);
         this.shown = undefined;
         this.clearSplitCoordinator();
         this.host.clearMouseModeSource(OFFSCREEN_MOUSE_SOURCE);
@@ -374,7 +408,7 @@ export class OffscreenController {
         ];
     }
     nextCompanionArtifactHint(binding) {
-        if (this.shown !== binding || !this.forks.has(binding))
+        if (this.shown !== binding)
             return undefined;
         const config = this.artifactConfigs[binding];
         if (!config)
@@ -387,8 +421,8 @@ export class OffscreenController {
     }
     cycleCompanionArtifact(binding) {
         const primary = this.artifactConfigs[binding];
-        const fork = this.forks.get(binding);
-        if (!primary || !fork)
+        const fork = this.presentedFork(binding);
+        if (!primary)
             return false;
         const count = this.companionArtifacts(primary).length;
         if (count <= 1)
@@ -404,21 +438,33 @@ export class OffscreenController {
     configurePresentation(binding, fork, cols, rows) {
         const artifact = this.activeArtifactConfig(binding);
         if (artifact && (cols >= SPLIT_COLLAPSE_AT_COLS || artifact.collapseWhenNarrow)) {
+            const index = this.activeArtifactIndexes.get(binding) ?? 0;
+            let panes = this.artifactPanes.get(binding);
+            if (!panes)
+                this.artifactPanes.set(binding, panes = new Map());
+            let artifactPane = panes.get(index);
+            if (!artifactPane) {
+                artifactPane = new ArtifactPaneController(artifact.renderArtifact, artifact.styleVersion);
+                panes.set(index, artifactPane);
+            }
             this.split = {
                 binding,
                 coordinator: new SplitInquiryCoordinator({
                     inquirySide: artifact.inquirySide,
-                    inquiryPane: new InquiryPaneController(fork),
-                    artifactPane: new ArtifactPaneController(artifact.renderArtifact, artifact.styleVersion),
+                    inquiryPane: fork ? new InquiryPaneController(fork, this.forks.has(binding)) : this.startingPane(binding),
+                    artifactPane,
                     collapseAt: SPLIT_COLLAPSE_AT_COLS,
                     collapseArtifact: artifact.collapseWhenNarrow,
                 }),
             };
-            fork.resize(this.split.coordinator.inquiryWidth(cols), this.split.coordinator.inquiryHeight(cols, rows));
+            fork?.resize(this.split.coordinator.inquiryWidth(cols), this.split.coordinator.inquiryHeight(cols, rows));
             return;
         }
         this.clearSplitCoordinator();
-        fork.resize(cols, rows);
+        fork?.resize(cols, rows);
+    }
+    startingPane(binding) {
+        return new StartingInquiryPane(this.slots.get(binding).roleLabel);
     }
     focusArtifactForCurrentIssue(binding) {
         if (this.shown !== binding)
@@ -444,60 +490,98 @@ export class OffscreenController {
             this.host.scheduleParentUiRender();
             return;
         }
-        void this.ensureFork(binding, slot)
-            .then((fork) => {
-            if (this.disposed) {
-                fork.kill();
-                return;
-            }
-            for (const [key, other] of this.forks) {
-                if (key !== binding)
-                    other.setVisible(false);
-            }
-            const layout = this.host.getLayout();
-            this.shown = binding;
-            this.configurePresentation(binding, fork, layout.columns, layout.childRows);
-            if (focusIssueArtifact)
-                this.focusArtifactForCurrentIssue(binding);
-            fork.setVisible(true);
-            this.updateForkState();
-            this.host.scheduleRender();
+        if (this.shown && this.shown !== binding)
+            this.abortIssueSend(this.shown);
+        for (const [key, other] of [...this.forks, ...this.pendingForks]) {
+            if (key !== binding)
+                other.setVisible(false);
+        }
+        const fork = this.forks.get(binding);
+        const presented = this.presentedFork(binding);
+        const layout = this.host.getLayout();
+        this.shown = binding;
+        this.configurePresentation(binding, presented, layout.columns, layout.childRows);
+        if (focusIssueArtifact)
+            this.focusArtifactForCurrentIssue(binding);
+        presented?.setVisible(true);
+        this.updateForkState();
+        this.host.scheduleRender();
+        if (fork) {
             if (question)
                 this.startInquirySend(binding, fork, question);
-        })
-            .catch((err) => {
-            this.clearSendPending(binding);
-            const reason = err instanceof Error ? err.message : String(err);
-            this.host.output.warn(`offscreen ${slot.roleLabel} fork failed: ${reason}`);
-            this.updateForkState();
-            this.host.scheduleParentUiRender();
-        });
+        }
+        else {
+            if (question)
+                this.pendingQuestions.set(binding, question);
+            this.ensureFork(binding, slot);
+        }
     }
     ensureFork(binding, slot) {
-        const existing = this.forks.get(binding);
-        if (existing)
-            return Promise.resolve(existing);
-        const pending = this.pending.get(binding);
-        if (pending)
-            return pending;
-        const layout = this.host.getLayout();
-        const created = Fork.spawn(slot, this.workdir, this.host, layout.columns, layout.childRows, () => this.updateForkState()).then((fork) => {
-            this.pending.delete(binding);
-            if (this.disposed) {
-                fork.kill();
-                return fork;
+        if (this.pending.has(binding))
+            return;
+        let constructed;
+        // The host's coalesced first frame must run before any provider preparation.
+        const created = new Promise((resolve) => setImmediate(resolve)).then(async () => {
+            this.launchAbort.signal.throwIfAborted();
+            const layout = this.host.getLayout();
+            return Fork.spawn(slot, this.workdir, this.host, layout.columns, layout.childRows, () => {
+                if (!this.disposed && constructed && this.presentedFork(binding) === constructed) {
+                    this.updateForkState();
+                }
+            }, this.observerRuns, this.launchAbort.signal, (fork) => {
+                constructed = fork;
+                if (this.disposed || this.pending.get(binding) !== created) {
+                    void fork.kill();
+                    return;
+                }
+                this.pendingForks.set(binding, fork);
+                if (this.shown !== binding)
+                    return;
+                const layout = this.host.getLayout();
+                this.configurePresentation(binding, fork, layout.columns, layout.childRows);
+                fork.setVisible(true);
+                this.updateForkState();
+                this.host.scheduleParentUiRender();
+            });
+        }).then(async (fork) => {
+            if (this.disposed || this.pending.get(binding) !== created) {
+                await fork.kill();
+                return;
             }
+            constructed = fork;
+            this.pendingForks.delete(binding);
             this.forks.set(binding, fork);
             if (this.tracksTurns) {
                 void this.ensureForkSession(binding, fork);
             }
-            return fork;
+            if (this.shown === binding) {
+                const layout = this.host.getLayout();
+                this.configurePresentation(binding, fork, layout.columns, layout.childRows);
+                fork.setVisible(true);
+                this.updateForkState();
+                this.host.scheduleRender();
+            }
+            const question = this.pendingQuestions.get(binding);
+            this.pendingQuestions.delete(binding);
+            if (question)
+                this.startInquirySend(binding, fork, question);
         }).catch((err) => {
-            this.pending.delete(binding);
-            throw err;
+            if (this.disposed && err === this.launchAbort.signal.reason)
+                return;
+            const reason = err instanceof Error ? err.message : String(err);
+            this.host.output.warn(`offscreen ${slot.roleLabel} fork failed: ${reason}`);
+            if (this.disposed || this.pending.get(binding) !== created)
+                return;
+            this.pendingQuestions.delete(binding);
+            this.clearSendPending(binding);
+            this.pendingForks.delete(binding);
+            if (this.shown === binding)
+                this.hideFork();
+        }).finally(() => {
+            if (this.pending.get(binding) === created)
+                this.pending.delete(binding);
         });
         this.pending.set(binding, created);
-        return created;
     }
     startInquirySend(binding, fork, question) {
         if (this.disposed || this.sendControllers.has(binding))
@@ -508,12 +592,22 @@ export class OffscreenController {
         this.sendLocks.add(binding);
         this.host.scheduleParentUiRender();
         const composer = resolveProvider(fork.driver).composer;
+        let receipt;
         void sendInquiryQuestion(fork, question, {
             signal: controller.signal,
             composer,
+            beforeSubmit: async () => {
+                await this.turnMonitors.get(binding)?.refreshExpiredAttempts();
+                controller.signal.throwIfAborted();
+                this.launchAbort.signal.throwIfAborted();
+                receipt = this.reserveTurn(binding);
+            },
+            onSubmitWritten: () => receipt?.markWritten(),
             onSubmitted: () => {
                 submitted = true;
-                this.beginTurn(binding);
+                receipt?.confirm();
+                if (!this.disposed && this.sendControllers.get(binding) === controller)
+                    this.clearSendPending(binding);
             },
         }).catch((err) => {
             if (!controller.signal.aborted) {
@@ -521,9 +615,20 @@ export class OffscreenController {
                 this.host.output.warn(`offscreen inquiry send failed: ${reason}`);
             }
         }).finally(() => {
-            if (this.sendControllers.get(binding) === controller) {
-                this.sendControllers.delete(binding);
+            receipt?.release();
+            if (this.disposed)
+                return;
+            if (receipt?.settlement === "released") {
+                const remaining = (this.pendingTurns.get(binding) ?? []).filter((pending) => pending !== receipt);
+                if (remaining.length > 0)
+                    this.pendingTurns.set(binding, remaining);
+                else
+                    this.pendingTurns.delete(binding);
+                this.refreshStagedActivity(binding);
             }
+            if (this.sendControllers.get(binding) !== controller)
+                return;
+            this.sendControllers.delete(binding);
             this.sendLocks.delete(binding);
             if (!submitted)
                 this.clearSendPending(binding);
@@ -539,44 +644,73 @@ export class OffscreenController {
     clearSendPending(binding) {
         if (!this.sendPending.delete(binding))
             return;
-        this.host.scheduleParentUiRender();
+        if (!this.disposed)
+            this.host.scheduleParentUiRender();
     }
-    beginTurn(binding) {
+    reserveTurn(binding, rawAttempt = false) {
         const pendingChanged = this.sendPending.delete(binding);
         const turnChanged = this.prepareTurn(binding);
         const monitor = this.turnMonitors.get(binding);
-        if (monitor)
-            monitor.beginTurn();
+        let receipt;
+        if (monitor) {
+            receipt = rawAttempt ? monitor.beginTurnAttempt() : monitor.reserveTurn();
+        }
         else {
-            this.pendingTurnGenerations.set(binding, (this.pendingTurnGenerations.get(binding) ?? 0) + 1);
+            receipt = new SessionTurnReceipt({
+                anchorSubmitCount: this.forkSubmitFloors.get(binding),
+            }, rawAttempt);
+            if (rawAttempt)
+                receipt.markWritten();
+            const pending = this.pendingTurns.get(binding) ?? [];
+            pending.push(receipt);
+            this.pendingTurns.set(binding, pending);
+            if (rawAttempt) {
+                this.pendingAttemptTimers.set(receipt.id, setTimeout(() => {
+                    this.pendingAttemptTimers.delete(receipt.id);
+                    if (this.disposed)
+                        return;
+                    receipt.settle("expired");
+                    this.refreshStagedActivity(binding);
+                }, Math.max(0, receipt.startedAt + this.turnAttemptTimeoutMs - Date.now())));
+            }
             this.ensureTurnPoll(binding);
         }
         if (pendingChanged || turnChanged)
             this.host.scheduleParentUiRender();
+        return receipt;
     }
     beginTurnAttempt(binding) {
-        const turnChanged = this.prepareTurn(binding);
-        const monitor = this.turnMonitors.get(binding);
-        if (monitor)
-            monitor.beginTurnAttempt();
-        else {
-            const attempts = this.pendingTurnAttempts.get(binding) ?? [];
-            attempts.push({
-                startedAt: Date.now(),
-                anchorSubmitCount: this.forkSubmitFloors.get(binding),
-            });
-            this.pendingTurnAttempts.set(binding, attempts);
-            this.ensureTurnPoll(binding);
+        this.reserveTurn(binding, true);
+    }
+    refreshStagedActivity(binding) {
+        const pending = this.pendingTurns.get(binding) ?? [];
+        if (pending.some((receipt) => !receipt.settlement)
+            || this.turnMonitors.get(binding)?.isIdle === false)
+            return;
+        if (pending.length === 0) {
+            this.releaseTurn(binding);
         }
-        if (turnChanged)
+        else if (this.turnInProgress.delete(binding)) {
+            // Retain expired receipts until discovery so late genuine work is still observed.
             this.host.scheduleParentUiRender();
+        }
+    }
+    needsTurnObservation(binding) {
+        return this.turnInProgress.has(binding) || this.pendingTurns.has(binding);
+    }
+    clearStagedAttemptTimers(binding) {
+        for (const receipt of this.pendingTurns.get(binding) ?? []) {
+            clearTimeout(this.pendingAttemptTimers.get(receipt.id));
+            this.pendingAttemptTimers.delete(receipt.id);
+        }
     }
     prepareTurn(binding) {
         const turnChanged = !this.turnInProgress.has(binding);
         this.turnInProgress.add(binding);
         const fork = this.forks.get(binding);
-        if (!this.forkSessionFiles.has(binding)
-            || (fork && this.needsSubmitFloor(binding, fork))) {
+        if (!this.turnMonitors.has(binding)
+            && (!this.forkSessionFiles.has(binding)
+                || (fork && this.needsSubmitFloor(binding, fork)))) {
             if (fork) {
                 this.forkLocateAborts.get(binding)?.abort();
                 this.forkSession.delete(binding);
@@ -587,8 +721,8 @@ export class OffscreenController {
     }
     releaseTurn(binding, lines) {
         const changed = this.turnInProgress.delete(binding);
-        this.pendingTurnGenerations.delete(binding);
-        this.pendingTurnAttempts.delete(binding);
+        this.clearStagedAttemptTimers(binding);
+        this.pendingTurns.delete(binding);
         this.clearTurnPoll(binding);
         this.forkLocateWarned.delete(binding);
         if (lines)
@@ -605,6 +739,17 @@ export class OffscreenController {
         const abort = new AbortController();
         this.forkLocateAborts.set(binding, abort);
         const promise = (async () => {
+            const liveMonitor = fork.createTurnMonitor?.(this.forkMonitorOptions(binding));
+            if (liveMonitor) {
+                this.installForkTurnMonitor(binding, liveMonitor);
+                return;
+            }
+            const policy = resolveProvider(fork.driver).forkSubmitFloor;
+            if (!policy) {
+                if (this.turnInProgress.has(binding))
+                    this.warnForkSessionUnavailable(binding);
+                return;
+            }
             await this.captureForkSubmitFloor(binding, fork, abort.signal);
             if (this.disposed || abort.signal.aborted)
                 return;
@@ -617,10 +762,10 @@ export class OffscreenController {
                 return;
             }
             this.forkSessionFiles.set(binding, file);
-            if (!this.turnInProgress.has(binding)) {
+            if (!this.needsTurnObservation(binding)) {
                 try {
-                    const lines = await readSessionFile(file);
-                    if (this.disposed || abort.signal.aborted || this.turnInProgress.has(binding))
+                    const lines = await readTurnHistory(fork.driver, file);
+                    if (this.disposed || abort.signal.aborted || this.needsTurnObservation(binding))
                         return;
                     this.refreshIdleBaseline(binding, lines);
                 }
@@ -629,29 +774,31 @@ export class OffscreenController {
                 }
             }
             else {
-                const policy = resolveProvider(fork.driver).forkSubmitFloor;
-                if (policy.from !== "fork-file"
-                    || this.forkSubmitFloors.has(binding)) {
-                    if (this.turnInProgress.has(binding))
-                        this.ensureTurnPoll(binding);
-                    return;
-                }
-                try {
-                    const lines = await readSessionFile(file);
-                    if (this.disposed || abort.signal.aborted || !this.turnInProgress.has(binding))
+                while (!this.disposed && !abort.signal.aborted && this.needsTurnObservation(binding)) {
+                    let lines;
+                    try {
+                        lines = await readTurnHistory(fork.driver, file);
+                    }
+                    catch {
+                        if (this.turnInProgress.has(binding))
+                            this.warnForkSessionUnavailable(binding);
+                        await waitForRetry(this.turnPollMs, abort.signal);
+                        continue;
+                    }
+                    if (this.disposed || abort.signal.aborted || !this.needsTurnObservation(binding))
                         return;
-                    const providerFloor = forkFileSubmitFloor(fork.driver, fork.lineage, lines);
-                    this.forkSubmitFloors.set(binding, providerFloor !== undefined
-                        ? 0
-                        :
-                            Math.max(0, submitCount(fork.driver, lines) + policy.offset));
-                    this.forkBaselines.set(binding, 0);
-                }
-                catch {
+                    if (policy.from === "fork-file" && !this.forkSubmitFloors.has(binding)) {
+                        const providerFloor = forkFileSubmitFloor(fork.driver, fork.lineage, lines);
+                        this.forkSubmitFloors.set(binding, providerFloor !== undefined
+                            ? 0
+                            : Math.max(0, submitCount(fork.driver, lines) + policy.offset));
+                        this.forkBaselines.set(binding, 0);
+                    }
+                    this.ensureTurnPoll(binding, lines);
                     return;
                 }
             }
-            if (this.turnInProgress.has(binding))
+            if (this.needsTurnObservation(binding))
                 this.ensureTurnPoll(binding);
         })().catch(() => {
             // Fail closed: leave the binding busy when session discovery/read fails.
@@ -664,7 +811,8 @@ export class OffscreenController {
         return promise;
     }
     async captureForkSubmitFloor(binding, fork, signal) {
-        if (resolveProvider(fork.driver).forkSubmitFloor.from !== "source")
+        const policy = resolveProvider(fork.driver).forkSubmitFloor;
+        if (!policy || policy.from !== "source")
             return;
         if (this.forkSubmitFloors.has(binding))
             return;
@@ -682,16 +830,17 @@ export class OffscreenController {
         const promise = (async () => {
             while (!this.disposed && !signal.aborted && slot) {
                 try {
-                    const lines = await readSessionFile(slot.sourceSessionPath);
+                    const lines = await readTurnHistory(fork.driver, slot.sourceSessionPath);
                     if (!this.disposed && !signal.aborted) {
                         this.forkSubmitFloors.set(binding, submitCount(fork.driver, lines));
                     }
                     return;
                 }
                 catch {
-                    if (!this.turnInProgress.has(binding))
+                    if (!this.needsTurnObservation(binding))
                         return;
-                    this.warnForkSessionUnavailable(binding);
+                    if (this.turnInProgress.has(binding))
+                        this.warnForkSessionUnavailable(binding);
                     await waitForRetry(this.turnPollMs, signal);
                 }
             }
@@ -706,8 +855,8 @@ export class OffscreenController {
     refreshIdleBaseline(binding, lines) {
         this.forkBaselines.set(binding, lines.length);
     }
-    ensureTurnPoll(binding) {
-        if (!this.turnInProgress.has(binding))
+    ensureTurnPoll(binding, initialLines) {
+        if (!this.needsTurnObservation(binding))
             return;
         if (this.turnMonitors.has(binding))
             return;
@@ -727,6 +876,8 @@ export class OffscreenController {
             void this.ensureForkSession(binding, fork);
             return;
         }
+        if (!resolveProvider(fork.driver).forkSubmitFloor)
+            return;
         const providerFork = resolveProvider(fork.driver).fork;
         const effectiveSubmitCount = providerFork.forkFileSubmitFloor
             ? (lines) => Math.max(0, submitCount(fork.driver, lines) -
@@ -738,6 +889,14 @@ export class OffscreenController {
             submitFloor: this.forkSubmitFloors.get(binding),
             submitCount: effectiveSubmitCount,
             readResult: readSessionFileWithStatus,
+            ...this.forkMonitorOptions(binding),
+        });
+        this.installForkTurnMonitor(binding, monitor);
+    }
+    forkMonitorOptions(binding) {
+        return {
+            pollMs: this.turnPollMs,
+            attemptTimeoutMs: this.turnAttemptTimeoutMs,
             onReadFailure: () => this.warnForkSessionUnavailable(binding),
             onHistorySnapshot: (snapshot) => {
                 this.forkBaselines.set(binding, snapshot.lineCount);
@@ -747,35 +906,43 @@ export class OffscreenController {
                 this.host.scheduleParentUiRender();
             },
             onChange: (idle) => {
-                if (!idle)
+                if (!idle) {
+                    if (!this.turnInProgress.has(binding)) {
+                        this.turnInProgress.add(binding);
+                        this.host.scheduleParentUiRender();
+                    }
                     return;
-                this.forkBaselines.set(binding, monitor.lineBaseline);
-                const submitFloor = monitor.currentSubmitFloor;
-                if (submitFloor !== undefined) {
-                    this.forkSubmitFloors.set(binding, submitFloor);
+                }
+                const monitor = this.turnMonitors.get(binding);
+                if (monitor) {
+                    this.forkBaselines.set(binding, monitor.lineBaseline);
+                    const submitFloor = monitor.currentSubmitFloor;
+                    if (submitFloor !== undefined) {
+                        this.forkSubmitFloors.set(binding, submitFloor);
+                    }
                 }
                 this.releaseTurn(binding);
             },
-        });
+        };
+    }
+    installForkTurnMonitor(binding, monitor, initialLines) {
         this.turnMonitors.set(binding, monitor);
-        const generations = this.pendingTurnGenerations.get(binding) ?? 0;
-        for (let generation = 0; generation < generations; generation++) {
-            monitor.beginTurn();
-        }
-        const attempts = this.pendingTurnAttempts.get(binding) ?? [];
-        for (const attempt of attempts) {
-            monitor.beginTurnAttempt(attempt);
-        }
-        this.pendingTurnGenerations.delete(binding);
-        this.pendingTurnAttempts.delete(binding);
+        const pending = this.pendingTurns.get(binding) ?? [];
+        this.clearStagedAttemptTimers(binding);
+        this.pendingTurns.delete(binding);
+        monitor.attachTurns(pending, initialLines);
     }
-    needsSubmitFloor(binding, _fork) {
+    needsSubmitFloor(binding, fork) {
+        if (!resolveProvider(fork.driver).forkSubmitFloor)
+            return false;
         return !this.forkSubmitFloors.has(binding);
     }
     clearTurnPoll(binding) {
         const monitor = this.turnMonitors.get(binding);
         if (monitor) {
-            if (monitor.supportsHistoryRegression)
+            if (monitor.supportsHistoryRegression
+                || monitor.hasUnobservedExpiredAttempts
+                || monitor.classifyDeliverySince)
                 return;
             monitor.dispose();
             this.turnMonitors.delete(binding);
@@ -789,8 +956,10 @@ export class OffscreenController {
             monitor.dispose();
         this.turnMonitors.clear();
         this.turnInProgress.clear();
-        this.pendingTurnGenerations.clear();
-        this.pendingTurnAttempts.clear();
+        for (const timer of this.pendingAttemptTimers.values())
+            clearTimeout(timer);
+        this.pendingAttemptTimers.clear();
+        this.pendingTurns.clear();
         this.forkSession.clear();
         this.forkSessionFiles.clear();
         this.forkBaselines.clear();
@@ -806,6 +975,7 @@ export class OffscreenController {
         this.host.output.warn(`offscreen inquiry fork session unavailable for ${binding}; inquiry remains busy`);
     }
     abortIssueSend(binding) {
+        this.pendingQuestions.delete(binding);
         const controller = this.sendControllers.get(binding);
         if (controller) {
             controller.abort(new Error("Inquiry send aborted"));
@@ -840,7 +1010,7 @@ export class OffscreenController {
     }
     updateVisibleMouseModes() {
         const fork = this.shown ? this.forks.get(this.shown) : undefined;
-        if (!fork) {
+        if (!this.shown) {
             this.host.clearMouseModeSource(OFFSCREEN_MOUSE_SOURCE);
             return;
         }
@@ -852,7 +1022,7 @@ export class OffscreenController {
         this.updateVisibleMouseModes();
     }
     visibleMouseModes(fork) {
-        const modes = fork.mouseModes();
+        const modes = fork?.mouseModes() ?? [];
         const coordinator = this.activeCoordinator();
         if (!coordinator)
             return modes;
@@ -884,6 +1054,13 @@ function inquiryShortcutForKey(key) {
 function waitForRetry(ms, signal) {
     return abortableSleep(ms, signal, { onAbort: "resolve" });
 }
+async function readTurnHistory(driver, path) {
+    const { lines, malformed } = await readSessionFileWithStatus(path);
+    if (malformed || resolveProvider(driver).fork.submissionEvidence?.(lines).indeterminate) {
+        throw new Error("Inquiry submission history is indeterminate");
+    }
+    return lines;
+}
 function isSubmitKey(key) {
     return key.kind === "enter"
         || key.kind === "shift-enter"