poly-weaver 0.15.2 → 1.0.0

package/dist/offscreen/session-turn-monitor.js

@@ -1,10 +1,9 @@
 import { resolveProvider } from "../providers/registry.js";
 import { readSessionFileWithStatus, } from "../session/reader.js";
-const DEFAULT_ATTEMPT_TIMEOUT_MS = 5_000;
-/**
- * Tracks one provider session from a settled line baseline to the completion
- * of each subsequently submitted turn. Read failures fail closed as busy.
- */
+import { SessionTurnReceipt } from "./session-turn-receipt.js";
+export { SessionTurnReceipt } from "./session-turn-receipt.js";
+export const DEFAULT_TURN_ATTEMPT_TIMEOUT_MS = 5_000;
+/** Ordered request ownership; provider observations remain work even without a host receipt. */
 export class SessionTurnMonitor {
     driver;
     sessionFilePath;
@@ -12,136 +11,174 @@ export class SessionTurnMonitor {
     baseline;
     busy = false;
     timer;
-    polling = false;
     activePoll;
     stopped = false;
-    turnGeneration = 0;
-    mappedGeneration = 0;
-    coveredGeneration = 0;
-    nextReservationSequence = 0;
-    pendingConfirmedTurns = [];
-    pendingTurnAttempts = [];
-    unreservedObservedGenerations = [];
-    pendingAttemptWaiters = new Set();
+    attachingBatch = false;
+    ownershipWarned = false;
+    entries = [];
+    attached = new Set();
+    attemptWaiters = new Set();
     observedSubmitCount;
     pollMs;
     attemptTimeoutMs;
     submitFloor;
     historySnapshot;
-    mappedSubmitIdentities = [];
     constructor(driver, sessionFilePath, baseline, options = {}) {
         this.driver = driver;
         this.sessionFilePath = sessionFilePath;
         this.options = options;
         this.baseline = Math.max(0, baseline);
         this.pollMs = options.pollMs ?? 500;
-        this.attemptTimeoutMs =
-            options.attemptTimeoutMs ?? DEFAULT_ATTEMPT_TIMEOUT_MS;
+        this.attemptTimeoutMs = options.attemptTimeoutMs ?? DEFAULT_TURN_ATTEMPT_TIMEOUT_MS;
         this.submitFloor = options.submitFloor;
         this.historySnapshot = options.initialHistorySnapshot;
     }
-    get isIdle() {
-        return !this.busy;
-    }
-    get lineBaseline() {
-        return this.baseline;
-    }
-    get currentSubmitFloor() {
-        return this.submitFloor;
+    get isIdle() { return !this.busy; }
+    get lineBaseline() { return this.baseline; }
+    get currentSubmitFloor() { return this.submitFloor; }
+    get hasUnobservedExpiredAttempts() {
+        return this.entries.some((entry) => entry.ordinal === undefined
+            && entry.receipt?.settlement === "expired");
     }
     get supportsHistoryRegression() {
-        return resolveProvider(this.driver).fork.sessionHistorySnapshot !== undefined;
+        const provider = resolveProvider(this.driver);
+        return provider.forkSubmitFloor !== undefined
+            && provider.fork.sessionHistorySnapshot !== undefined;
     }
-    expectedSubmitCount(lines) {
-        const snapshot = this.reconcileHistory(lines);
-        this.observeSubmissions(lines, undefined, snapshot);
-        return (this.observedSubmitCount ?? 0)
-            + this.pendingConfirmedTurns.length
-            + this.pendingTurnAttempts.length;
+    reserveTurn(boundary = {}) {
+        const receipt = new SessionTurnReceipt({
+            ...boundary,
+            anchorSubmitCount: boundary.anchorSubmitCount ?? this.observedSubmitCount ?? this.submitFloor,
+        });
+        this.attachTurn(receipt);
+        return receipt;
     }
-    startHistoryPolling() {
-        if (this.stopped || !this.supportsHistoryRegression)
-            return;
-        this.ensurePolling();
+    async reserveTurnFromSession() {
+        await this.expectedSubmitCountFromSession();
+        return this.reserveTurn();
     }
-    waitForPendingTurnAttempts() {
-        if (this.pendingTurnAttempts.length === 0 || this.stopped) {
-            return Promise.resolve();
+    /** Attach the same pre-input receipt after discovery, never an anonymous later registration. */
+    attachTurns(receipts, initialLines) {
+        this.attachingBatch = true;
+        try {
+            for (const receipt of [...receipts].sort((a, b) => a.sequence - b.sequence))
+                this.attachTurn(receipt);
+            if (initialLines)
+                this.expectedSubmitCount(initialLines);
         }
-        return new Promise((resolve) => {
-            this.pendingAttemptWaiters.add(resolve);
-        });
+        finally {
+            this.attachingBatch = false;
+        }
+        this.updateActivity(true);
+        if (this.busy || this.hasUnobservedExpiredAttempts)
+            this.ensurePolling();
     }
-    beginTurn() {
-        if (this.stopped)
+    attachTurn(receipt) {
+        if (this.stopped || this.attached.has(receipt.id))
             return;
-        if (this.adoptUnreservedObservedSubmit())
+        this.attached.add(receipt.id);
+        if (receipt.settlement && receipt.settlement !== "expired")
             return;
-        this.turnGeneration++;
-        this.pendingConfirmedTurns.push({
-            sequence: this.nextReservationSequence++,
-            anchorSubmitCount: this.observedSubmitCount ?? this.submitFloor,
+        const anchor = receipt.anchorSubmitCount ?? this.observedSubmitCount ?? this.submitFloor;
+        const observed = anchor === undefined ? undefined : this.entries.find((entry) => !entry.receipt && entry.ordinal !== undefined && entry.ordinal > anchor);
+        const entry = observed ?? { anchor };
+        entry.receipt = receipt;
+        if (!observed)
+            this.entries.push(entry);
+        entry.unsubscribe = receipt.onChange(() => {
+            if (this.stopped)
+                return;
+            if (receipt.settlement === "released" && entry.ordinal === undefined) {
+                this.removeEntry(entry);
+                this.updateActivity();
+            }
         });
-        if (!this.busy) {
-            this.busy = true;
-            this.options.onChange?.(false);
+        if (receipt.rawAttempt && !receipt.settlement && entry.ordinal === undefined) {
+            const remainingMs = receipt.startedAt + this.attemptTimeoutMs - Date.now();
+            if (remainingMs <= 0) {
+                receipt.settle("expired");
+            }
+            else {
+                entry.timer = setTimeout(() => {
+                    if (this.stopped || entry.ordinal !== undefined)
+                        return;
+                    entry.timer = undefined;
+                    // Expiry releases speculative busy state, not its place ahead of later input.
+                    receipt.settle("expired");
+                    this.updateActivity();
+                }, remainingMs);
+            }
         }
-        this.ensurePolling();
+        this.updateActivity(receipt.settlement === "expired");
+        if (entry.settlement)
+            receipt.settle(entry.settlement);
+        if (!this.attachingBatch && (this.busy || this.hasUnobservedExpiredAttempts))
+            this.ensurePolling();
+    }
+    beginTurn(receipt = this.reserveTurn()) {
+        this.attachTurn(receipt);
+        receipt.confirm();
+        return receipt;
     }
-    beginTurnAttempt(snapshot = {}) {
+    beginTurnAttempt(boundary = {}) {
+        const receipt = new SessionTurnReceipt({
+            ...boundary,
+            anchorSubmitCount: boundary.anchorSubmitCount ?? this.observedSubmitCount ?? this.submitFloor,
+        }, true);
+        receipt.markWritten();
+        this.attachTurn(receipt);
+        return receipt;
+    }
+    expectedSubmitCount(lines) {
         if (this.stopped)
-            return;
-        if (this.adoptUnreservedObservedSubmit())
-            return;
-        const startedAt = snapshot.startedAt ?? Date.now();
-        const expired = Date.now() - startedAt >= this.attemptTimeoutMs;
-        const attempt = {
-            sequence: this.nextReservationSequence++,
-            anchorSubmitCount: snapshot.anchorSubmitCount
-                ?? this.observedSubmitCount
-                ?? this.submitFloor,
-            expired,
-        };
-        if (attempt.expired) {
-            this.releaseIfSettled({ notifyIfAlreadyIdle: true });
-            return;
-        }
-        attempt.timer = setTimeout(() => {
-            if (this.stopped || !this.pendingTurnAttempts.includes(attempt))
-                return;
-            attempt.expired = true;
-            this.discardExpiredAttempts();
-            this.releaseIfSettled();
-        }, Math.max(0, startedAt + this.attemptTimeoutMs - Date.now()));
-        this.pendingTurnAttempts.push(attempt);
-        if (!this.busy) {
-            this.busy = true;
-            this.options.onChange?.(false);
-        }
-        this.ensurePolling();
+            throw new Error("Session turn monitor is shut down");
+        const evidence = this.validateEvidence(lines);
+        const snapshot = this.reconcileHistory(lines);
+        this.observeSubmissions(lines, snapshot, evidence);
+        if (!this.attachingBatch && (this.busy || this.hasUnobservedExpiredAttempts))
+            this.ensurePolling();
+        return (this.observedSubmitCount ?? 0)
+            + this.entries.filter((entry) => entry.ordinal === undefined && !entry.receipt?.settlement).length;
+    }
+    startHistoryPolling() {
+        if (!this.stopped && this.supportsHistoryRegression)
+            this.ensurePolling();
+    }
+    waitForPendingTurnAttempts() {
+        if (!this.hasPendingAttempts() || this.stopped)
+            return Promise.resolve();
+        return new Promise((resolve) => this.attemptWaiters.add(resolve));
     }
     async refreshIdleBaseline() {
-        const result = await this.readLineResult();
-        if (result.malformed)
-            throw new Error("Session log contains malformed JSONL");
-        this.reconcileHistory(result.lines);
-        this.baseline = result.lines.length;
+        const result = await this.readValidResult();
+        this.expectedSubmitCount(result.lines);
+        if (this.isIdle)
+            this.baseline = result.lines.length;
+        this.retireNonSubmittingAttempts(result);
     }
     async expectedSubmitCountFromSession() {
-        const result = await this.readLineResult();
-        if (result.malformed)
-            throw new Error("Session log contains malformed JSONL");
-        return this.expectedSubmitCount(result.lines);
+        const result = await this.readValidResult();
+        const count = this.expectedSubmitCount(result.lines);
+        this.retireNonSubmittingAttempts(result);
+        return count;
+    }
+    async refreshExpiredAttempts() {
+        if (!this.hasUnobservedExpiredAttempts)
+            return;
+        await this.activePoll;
+        if (this.hasUnobservedExpiredAttempts)
+            await this.pollNow();
     }
     dispose() {
         if (this.timer)
             clearInterval(this.timer);
         this.timer = undefined;
-        for (const attempt of this.pendingTurnAttempts) {
-            if (attempt.timer)
-                clearTimeout(attempt.timer);
+        for (const entry of this.entries) {
+            if (entry.timer)
+                clearTimeout(entry.timer);
+            entry.unsubscribe?.();
         }
-        this.resolvePendingAttemptWaiters();
+        this.resolveAttemptWaiters();
     }
     async shutdown() {
         this.stopped = true;
@@ -149,234 +186,245 @@ export class SessionTurnMonitor {
         await this.activePoll;
     }
     pollNow() {
-        if ((!this.busy && !this.supportsHistoryRegression) || this.stopped) {
+        if (this.jsonlRuntimeDisabled())
+            return Promise.resolve();
+        if ((!this.busy && !this.supportsHistoryRegression && !this.hasUnobservedExpiredAttempts)
+            || this.stopped) {
             return Promise.resolve();
         }
-        if (this.polling)
-            return this.activePoll ?? Promise.resolve();
-        this.polling = true;
-        let active;
-        active = this.pollOnce()
-            .catch((err) => {
+        if (this.activePoll)
+            return this.activePoll;
+        const active = this.pollOnce()
+            .catch((error) => {
             if (!this.stopped)
-                this.options.onReadFailure?.(err);
+                this.options.onReadFailure?.(error);
         })
             .finally(() => {
             if (this.activePoll === active)
                 this.activePoll = undefined;
-            this.polling = false;
         });
         this.activePoll = active;
         return active;
     }
     async pollOnce() {
-        const result = await this.readLineResult();
-        if (result.malformed)
-            throw new Error("Session log contains malformed JSONL");
-        const lines = result.lines;
+        const result = await this.readValidResult();
+        const { lines } = result;
         if (this.stopped)
             return;
-        const provider = resolveProvider(this.driver);
-        const snapshot = this.reconcileHistory(lines);
-        const priorSubmitCount = this.submitFloor
-            ?? this.countSubmits(lines.slice(0, this.baseline));
-        const currentSubmitCount = this.observeSubmissions(lines, priorSubmitCount, snapshot);
-        this.discardExpiredAttempts();
-        const unsettledSubmits = currentSubmitCount - priorSubmitCount;
-        if (unsettledSubmits > 0) {
-            const tail = lines.slice(this.baseline);
-            const latestSubmit = provider.fork.latestSubmitIndex(tail);
-            if (latestSubmit >= 0
-                && provider.fork.turnComplete(lines, this.baseline + latestSubmit)) {
-                this.submitFloor = currentSubmitCount;
-                this.coveredGeneration = Math.min(this.mappedGeneration, this.coveredGeneration + unsettledSubmits);
-                this.baseline = lines.length;
+        const evidence = this.validateEvidence(lines, this.options.pendingEvidencePolicy === "wait");
+        if (evidence?.indeterminate) {
+            const { prior, assignments } = this.prepareObservation(lines);
+            if (this.inspectHistory(lines).regression) {
+                throw new Error("Session submission history regressed during pending evidence");
             }
+            // Check projected ownership without committing any part of an incomplete observation.
+            this.warnAmbiguousOwnership(this.entries.map((entry) => ({
+                ...entry,
+                anchor: entry.anchor ?? prior,
+                ordinal: entry.ordinal ?? assignments.get(entry),
+            })));
+            return;
         }
-        this.releaseIfSettled();
-    }
-    observeSubmissions(lines, priorSubmitCount = this.submitFloor
-        ?? this.countSubmits(lines.slice(0, this.baseline)), snapshot) {
-        const currentSubmitCount = this.countSubmits(lines);
-        const observedSubmitCount = this.observedSubmitCount ?? priorSubmitCount;
-        for (const attempt of this.pendingTurnAttempts) {
-            attempt.anchorSubmitCount ??= observedSubmitCount;
-        }
-        for (const turn of this.pendingConfirmedTurns) {
-            turn.anchorSubmitCount ??= observedSubmitCount;
+        const snapshot = this.reconcileHistory(lines);
+        const current = this.observeSubmissions(lines, snapshot, evidence);
+        this.retireNonSubmittingAttempts(result);
+        let aggregateComplete = false;
+        if (!evidence) {
+            const fork = resolveProvider(this.driver).fork;
+            const latest = fork.latestSubmitIndex(lines);
+            aggregateComplete = latest >= this.baseline && fork.turnComplete(lines, latest);
         }
-        this.mapNewSubmits(observedSubmitCount, currentSubmitCount, snapshot);
-        this.observedSubmitCount = Math.max(observedSubmitCount, currentSubmitCount);
-        return currentSubmitCount;
-    }
-    mapNewSubmits(observedSubmitCount, currentSubmitCount, snapshot) {
-        for (let submitOrdinal = observedSubmitCount + 1; submitOrdinal <= currentSubmitCount; submitOrdinal++) {
-            const turnIndex = this.pendingConfirmedTurns.findIndex((turn) => turn.anchorSubmitCount !== undefined
-                && submitOrdinal > turn.anchorSubmitCount);
-            const attemptIndex = this.pendingTurnAttempts.findIndex((attempt) => attempt.anchorSubmitCount !== undefined
-                && submitOrdinal > attempt.anchorSubmitCount);
-            const turn = turnIndex >= 0
-                ? this.pendingConfirmedTurns[turnIndex]
-                : undefined;
-            const attempt = attemptIndex >= 0
-                ? this.pendingTurnAttempts[attemptIndex]
-                : undefined;
-            if (turn && (!attempt || turn.sequence < attempt.sequence)) {
-                this.pendingConfirmedTurns.splice(turnIndex, 1);
-                this.mappedGeneration++;
-                this.rememberMappedSubmitIdentity(snapshot, submitOrdinal);
+        const offset = evidence ? evidence.submissions.length - current : 0;
+        for (const entry of this.entries) {
+            if (entry.ordinal === undefined || entry.settlement)
                 continue;
-            }
-            if (!attempt) {
-                this.mapUnreservedObservedSubmit(snapshot, submitOrdinal);
-                continue;
-            }
-            this.pendingTurnAttempts.splice(attemptIndex, 1);
-            if (attempt.timer)
-                clearTimeout(attempt.timer);
-            this.turnGeneration++;
-            this.mappedGeneration++;
-            this.rememberMappedSubmitIdentity(snapshot, submitOrdinal);
-            continue;
+            entry.settlement = evidence
+                ? evidence.submissions[entry.ordinal - 1 + offset]?.settlement
+                : aggregateComplete ? "completed" : undefined;
         }
-        this.resolvePendingAttemptWaitersIfSettled();
-    }
-    mapUnreservedObservedSubmit(snapshot, submitOrdinal) {
-        this.turnGeneration++;
-        this.mappedGeneration++;
-        this.unreservedObservedGenerations.push(this.mappedGeneration);
-        this.rememberMappedSubmitIdentity(snapshot, submitOrdinal);
-        if (!this.busy) {
-            this.busy = true;
-            this.options.onChange?.(false);
+        if (this.entries.some((entry) => entry.ordinal !== undefined)
+            && this.entries.every((entry) => entry.ordinal === undefined || entry.settlement)) {
+            this.submitFloor = current;
+            this.baseline = lines.length;
         }
-    }
-    adoptUnreservedObservedSubmit() {
-        const generation = this.unreservedObservedGenerations.shift();
-        if (generation === undefined)
-            return false;
-        if (generation > this.coveredGeneration && !this.busy) {
-            this.busy = true;
-            this.options.onChange?.(false);
+        this.updateActivity();
+        if (this.busy)
             this.ensurePolling();
-            return true;
+        for (const entry of this.entries) {
+            if (this.stopped)
+                break;
+            if (entry.settlement)
+                entry.receipt?.settle(entry.settlement);
         }
-        this.releaseIfSettled();
-        return true;
     }
-    rememberMappedSubmitIdentity(snapshot, submitOrdinal) {
-        const identity = snapshot?.submitIdentities[submitOrdinal - 1];
-        if (identity)
-            this.mappedSubmitIdentities.push(identity);
+    jsonlRuntimeDisabled() {
+        return resolveProvider(this.driver).forkSubmitFloor === undefined;
     }
-    reconcileHistory(lines) {
-        const fork = resolveProvider(this.driver).fork;
-        const buildSnapshot = fork.sessionHistorySnapshot;
-        if (!buildSnapshot)
-            return undefined;
-        const current = buildSnapshot(lines);
-        if (!current) {
-            throw new Error("Session history snapshot is unbuildable");
-        }
-        const previous = this.historySnapshot;
-        if (previous && fork.compareSessionHistory) {
-            const regression = fork.compareSessionHistory(previous, current);
-            if (regression) {
-                this.applyHistoryRegression(regression, current);
-                this.historySnapshot = current;
-                this.options.onHistoryRegression?.(regression, current);
-                return current;
-            }
+    observeSubmissions(lines, snapshot, evidence) {
+        const { current, prior, assignments } = this.prepareObservation(lines);
+        for (const entry of this.entries)
+            entry.anchor ??= prior;
+        for (const [entry, ordinal] of assignments) {
+            entry.ordinal = ordinal;
+            entry.identity = evidence?.submissions[ordinal - 1 + evidence.submissions.length - current]?.identity
+                ?? snapshot?.submitIdentities[ordinal - 1 + snapshot.submitCount - current];
+            if (entry.timer)
+                clearTimeout(entry.timer);
+            if (!this.entries.includes(entry))
+                this.entries.push(entry);
         }
-        const changed = !sameHistorySnapshot(previous, current);
-        this.historySnapshot = current;
-        if (changed)
-            this.options.onHistorySnapshot?.(current);
+        this.observedSubmitCount = current;
+        this.updateActivity();
+        this.warnAmbiguousOwnership();
         return current;
     }
-    applyHistoryRegression(regression, snapshot) {
-        const currentIdentities = new Set(snapshot.submitIdentities);
-        let removedMapped = 0;
-        for (let index = this.mappedSubmitIdentities.length - 1; index >= 0; index--) {
-            const identity = this.mappedSubmitIdentities[index];
-            if (currentIdentities.has(identity))
-                continue;
-            this.mappedSubmitIdentities.splice(index, 1);
-            removedMapped++;
-        }
-        if (removedMapped > 0) {
-            this.mappedGeneration = Math.max(0, this.mappedGeneration - removedMapped);
-            this.coveredGeneration = Math.min(this.mappedGeneration, Math.max(0, this.coveredGeneration - removedMapped));
-            this.turnGeneration = Math.max(this.pendingTurnAttempts.length + this.pendingConfirmedTurns.length, this.turnGeneration - removedMapped);
+    prepareObservation(lines) {
+        const current = this.countSubmits(lines);
+        const prior = this.observedSubmitCount ?? this.submitFloor
+            ?? this.countSubmits(lines.slice(0, this.baseline));
+        if (current < prior || this.baseline > lines.length) {
+            throw new Error("Session submission history regressed without a provider history boundary");
         }
-        this.baseline = 0;
-        this.submitFloor = Math.min(this.submitFloor ?? regression.commonSubmitCount, regression.commonSubmitCount);
-        this.observedSubmitCount = Math.min(this.observedSubmitCount ?? regression.commonSubmitCount, regression.commonSubmitCount);
-        for (const turn of this.pendingConfirmedTurns) {
-            if (turn.anchorSubmitCount !== undefined) {
-                turn.anchorSubmitCount = Math.min(turn.anchorSubmitCount, regression.commonSubmitCount);
-            }
+        const pending = this.entries
+            .filter((entry) => entry.ordinal === undefined)
+            .sort((a, b) => a.receipt.sequence - b.receipt.sequence);
+        const assignments = new Map();
+        for (let ordinal = prior + 1; ordinal <= current; ordinal++) {
+            const index = pending.findIndex((entry) => ordinal > (entry.anchor ?? prior));
+            const entry = index < 0 ? {} : pending.splice(index, 1)[0];
+            assignments.set(entry, ordinal);
         }
-        for (const attempt of this.pendingTurnAttempts) {
-            if (attempt.anchorSubmitCount !== undefined) {
-                attempt.anchorSubmitCount = Math.min(attempt.anchorSubmitCount, regression.commonSubmitCount);
-            }
+        return { current, prior, assignments };
+    }
+    warnAmbiguousOwnership(entries = this.entries) {
+        const ambiguous = entries.some(({ receipt, ordinal }) => {
+            if (receipt?.settlement !== "expired" || ordinal === undefined)
+                return false;
+            return entries.some((newer) => newer.ordinal === undefined && newer.receipt && !newer.receipt.settlement
+                && newer.receipt.sequence > receipt.sequence
+                && newer.anchor !== undefined && newer.anchor < ordinal);
+        });
+        if (ambiguous && !this.ownershipWarned && !this.stopped) {
+            this.options.onReadFailure?.(new Error("Session submission ownership is ambiguous after an expired input attempt"));
         }
-        this.unreservedObservedGenerations.length = 0;
+        this.ownershipWarned = ambiguous;
     }
-    discardExpiredAttempts() {
-        for (let index = this.pendingTurnAttempts.length - 1; index >= 0; index--) {
-            const attempt = this.pendingTurnAttempts[index];
-            if (!attempt.expired)
+    retireNonSubmittingAttempts(read) {
+        if (this.stopped || read.registrationCount !== this.attached.size)
+            return;
+        let removed = false;
+        for (const entry of read.expiredAttempts) {
+            if (entry.ordinal !== undefined || !this.entries.includes(entry))
                 continue;
-            if (attempt.timer)
-                clearTimeout(attempt.timer);
-            this.pendingTurnAttempts.splice(index, 1);
+            this.removeEntry(entry);
+            removed = true;
+        }
+        if (removed)
+            this.updateActivity(true);
+    }
+    validateEvidence(lines, allowPending = false) {
+        const evidence = resolveProvider(this.driver).fork.submissionEvidence?.(lines);
+        if (evidence?.indeterminate && !(allowPending && evidence.indeterminateReason === "pending-submission")) {
+            throw new Error("Session submission evidence is indeterminate");
         }
-        this.resolvePendingAttemptWaitersIfSettled();
+        return evidence;
+    }
+    inspectHistory(lines) {
+        const fork = resolveProvider(this.driver).fork;
+        if (!fork.sessionHistorySnapshot)
+            return {};
+        const current = fork.sessionHistorySnapshot(lines);
+        if (!current)
+            throw new Error("Session history snapshot is unbuildable");
+        const previous = this.historySnapshot;
+        const regression = previous && fork.compareSessionHistory?.(previous, current);
+        return { snapshot: current, regression };
     }
-    resolvePendingAttemptWaitersIfSettled() {
-        if (this.pendingTurnAttempts.length === 0) {
-            this.resolvePendingAttemptWaiters();
+    reconcileHistory(lines) {
+        const { snapshot: current, regression } = this.inspectHistory(lines);
+        if (!current)
+            return undefined;
+        const previous = this.historySnapshot;
+        if (regression) {
+            const identities = new Set(current.submitIdentities);
+            for (const entry of [...this.entries]) {
+                if (entry.identity && !identities.has(entry.identity)) {
+                    this.removeEntry(entry);
+                    entry.receipt?.settle("removed");
+                }
+                else if (entry.ordinal === undefined && entry.anchor !== undefined) {
+                    entry.anchor = Math.min(entry.anchor, regression.commonSubmitCount);
+                }
+            }
+            this.baseline = 0;
+            this.submitFloor = Math.min(this.submitFloor ?? regression.commonSubmitCount, regression.commonSubmitCount);
+            this.observedSubmitCount = Math.min(this.observedSubmitCount ?? regression.commonSubmitCount, regression.commonSubmitCount);
+            this.historySnapshot = current;
+            if (!this.stopped)
+                this.options.onHistoryRegression?.(regression, current);
+        }
+        else {
+            this.historySnapshot = current;
+            if (!this.stopped && !sameHistorySnapshot(previous, current))
+                this.options.onHistorySnapshot?.(current);
         }
+        return current;
+    }
+    removeEntry(entry) {
+        if (entry.timer)
+            clearTimeout(entry.timer);
+        entry.unsubscribe?.();
+        const index = this.entries.indexOf(entry);
+        if (index >= 0)
+            this.entries.splice(index, 1);
+    }
+    hasPendingAttempts() {
+        return this.entries.some((entry) => entry.receipt?.rawAttempt && !entry.receipt.settlement
+            && entry.ordinal === undefined);
     }
-    resolvePendingAttemptWaiters() {
-        for (const resolve of this.pendingAttemptWaiters)
+    resolveAttemptWaiters() {
+        for (const resolve of this.attemptWaiters)
             resolve();
-        this.pendingAttemptWaiters.clear();
+        this.attemptWaiters.clear();
     }
-    releaseIfSettled(options = {}) {
-        if (this.coveredGeneration !== this.turnGeneration
-            || this.pendingTurnAttempts.length > 0) {
+    updateActivity(notifyIfAlreadyIdle = false) {
+        if (this.attachingBatch)
             return;
+        if (!this.hasPendingAttempts())
+            this.resolveAttemptWaiters();
+        const busy = this.entries.some((entry) => entry.ordinal === undefined
+            ? !entry.receipt?.settlement : !entry.settlement);
+        const changed = busy !== this.busy;
+        this.busy = busy;
+        if (!busy && !this.supportsHistoryRegression && !this.hasUnobservedExpiredAttempts && this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
         }
-        const wasBusy = this.busy;
-        this.busy = false;
-        if (!this.supportsHistoryRegression)
-            this.dispose();
-        if ((wasBusy || options.notifyIfAlreadyIdle === true) && !this.stopped) {
-            this.options.onChange?.(true);
+        if (!this.stopped && (changed || (!busy && notifyIfAlreadyIdle))) {
+            this.options.onChange?.(!busy);
         }
     }
     ensurePolling() {
-        if (this.timer)
+        if (this.stopped || this.timer)
             return;
-        this.timer = setInterval(() => {
+        this.timer = setInterval(() => { void this.pollNow(); }, this.pollMs);
+        if (this.busy || this.supportsHistoryRegression)
             void this.pollNow();
-        }, this.pollMs);
-        void this.pollNow();
     }
-    async readLineResult() {
-        if (this.options.readResult) {
-            return this.options.readResult(this.sessionFilePath);
-        }
-        if (this.options.readLines) {
-            return {
-                lines: await this.options.readLines(this.sessionFilePath),
-                malformed: false,
-            };
-        }
-        return readSessionFileWithStatus(this.sessionFilePath);
+    async readValidResult() {
+        // Only a post-expiry read, uninterrupted by newer input, can release ownership.
+        const expiredAttempts = this.entries.filter(({ receipt, ordinal }) => ordinal === undefined && receipt?.settlement === "expired"
+            && !this.entries.some((newer) => newer.receipt && !newer.receipt.settlement
+                && newer.receipt.sequence > receipt.sequence));
+        const registrationCount = this.attached.size;
+        const result = this.options.readResult
+            ? await this.options.readResult(this.sessionFilePath)
+            : this.options.readLines
+                ? { lines: await this.options.readLines(this.sessionFilePath), malformed: false }
+                : await readSessionFileWithStatus(this.sessionFilePath);
+        if (result.malformed)
+            throw new Error("Session log contains malformed JSONL");
+        return { ...result, expiredAttempts, registrationCount };
     }
     countSubmits(lines) {
         return this.options.submitCount
@@ -385,9 +433,7 @@ export class SessionTurnMonitor {
     }
 }
 function sameHistorySnapshot(left, right) {
-    if (!left)
-        return false;
-    return left.lineCount === right.lineCount
+    return left !== undefined && left.lineCount === right.lineCount
         && left.submitCount === right.submitCount
         && left.submitIdentities.length === right.submitIdentities.length
         && left.submitIdentities.every((identity, index) => identity === right.submitIdentities[index]);