poly-weaver 1.1.1 → 1.2.0

package/dist/providers/copilot/observation.js

@@ -1,4 +1,5 @@
 import { randomBytes, randomUUID } from "node:crypto";
+import { cleanupResources } from "../../cleanup.js";
 import { COPILOT_PARENT_ENV_TO_CLEAR } from "./environment.js";
 import { FileAndTurnCompletionGate, validateCompletionPolicy } from "../completion-gate.js";
 import { existsSync } from "node:fs";
@@ -16,6 +17,7 @@ import { recordProp, stringProp, rawStringProp } from "./record-properties.js";
 import { CopilotBackgroundWorkState, CopilotFinalBoundaryState, isCopilotTurnInitiatingUserLine as isLiveRootSubmit, } from "./completion.js";
 import { getCopilotSessionDir } from "./session.js";
 import { CopilotComposerInspector } from "./composer.js";
+import { describeRecoveryEvent, matchesHistoryEvidence } from "./observer-extension/com.github.copilot/extensions/poly-weaver-observer/history-evidence.mjs";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const OBSERVER_PLUGIN_ASSET_DIR = join(__dirname, "observer-extension");
 const OBSERVER_PLUGIN_TEMPLATE_NAME = "poly-weaver-copilot-observer";
@@ -24,7 +26,7 @@ const OBSERVER_PLUGIN_IDENTITY_PREFIX = "poly-weaver-observer";
 const COPILOT_PLUGIN_NAME_MAX_LENGTH = 64;
 const COPILOT_PLUGIN_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const COPILOT_EXTENSIONS_CONTRACT = "com.github.copilot/extensions";
-const READY_TIMEOUT_MS = 60_000;
+const READY_TIMEOUT_MS = 5 * 60_000;
 const PLAN_READ_TIMEOUT_MS = 5_000;
 const PLAN_READ_RETRY_MS = 250;
 const OBSERVER_DIAGNOSTIC_EVENT_TAIL_LIMIT = 80;
@@ -152,8 +154,8 @@ export class CopilotObservationBroker {
                 parts = [];
                 return;
             }
-            // Let admitted replay catch up before accepting more live frames. The
-            // paused socket carries this pressure back to the extension's writer.
+            // Committed live reductions backpressure the parser. Activation must
+            // instead consume already-received ingress before publishing its draft.
             if (authed?.isConnectionDraining(socket)) {
                 scheduled = setImmediate(drain);
                 return;
@@ -204,7 +206,7 @@ export class CopilotObservationBroker {
                     }
                     let decision;
                     try {
-                        decision = registration.authenticate(message, socket);
+                        decision = registration.authenticate(message, socket, () => pendingChars > 0 || frameChars > 0);
                         sendAuthResult(socket, decision);
                         if (!decision.accepted) {
                             socket.end();
@@ -233,9 +235,16 @@ export class CopilotObservationBroker {
                 chunks = [];
                 cursor = 0;
                 if (ended) {
+                    if (frameChars > 0) {
+                        fail("Copilot observer disconnected with an incomplete frame");
+                        return;
+                    }
                     authed?.finishConnection(socket, closeCause);
                     stopped = true;
                 }
+                else if (frameChars === 0 && authed?.isConnectionBackpressured(socket)) {
+                    scheduled = setImmediate(drain);
+                }
                 else {
                     socket.resume();
                 }
@@ -259,6 +268,15 @@ export class CopilotObservationBroker {
             if (!stopped)
                 scheduled ??= setImmediate(drain);
         });
+        socket.on("end", () => {
+            ended = true;
+            // EOF can precede the final admitted transaction. Record the close now
+            // when ingress is exhausted, rather than granting that epoch a new deadline.
+            if (cursor >= chunks.length && frameChars === 0)
+                authed?.finishConnection(socket, closeCause);
+            if (!stopped)
+                scheduled ??= setImmediate(drain);
+        });
         socket.on("error", (err) => {
             closeCause = err;
         });
@@ -275,27 +293,51 @@ export class CopilotLaunchRegistration {
     consumed = false;
     connectionAttemptCount = 0;
     rejectedDuplicateCount = 0;
-    lifecycleEventCount = 0;
     epochCount = 0;
     observerReadinessTimeoutMs = READY_TIMEOUT_MS;
     workspacePath;
     preferredExtensionDir;
     readyIdentityValue;
     recoveryCause;
+    continuityProblem;
+    startupVerificationProblem;
+    lastRecoveryMode;
+    recoveryBoundaryStatus = "established";
+    recoveryRejection;
     recoveryDeadlineAt;
     recoveryTimer;
     failed;
     disposed = false;
-    events = [];
-    seenEventIds = new Set();
-    seenEventReplayKeys = new Set();
+    state = new CopilotObservationState();
+    automatedRequest;
+    requestRisks = new Set();
     excludeInheritedHistory = false;
     inheritedEventIds;
     eventHandlers = new Set();
     errorHandlers = new Set();
     readyWaiters = new Set();
     pendingRpcs = new Map();
-    evidence = new CopilotLiveEvidence();
+    get evidence() { return this.state.evidence; }
+    get recoveryWatermark() { return this.state.watermark; }
+    get continuityAvailable() {
+        return !this.failed && !this.disposed && !this.recoveryCause && this.activeConnection?.committed === true;
+    }
+    get outcomesAvailable() {
+        return this.continuityAvailable && this.currentReadyIdentity() !== undefined;
+    }
+    prepareRequest(prompt) {
+        return this.automatedRequest = { prompt, written: false };
+    }
+    requestForDetector() { return this.automatedRequest; }
+    trackRequestRisk(risk) {
+        this.requestRisks.add(risk);
+        return () => this.requestRisks.delete(risk);
+    }
+    mayHaveExecutingRequest() {
+        return Boolean(this.automatedRequest?.written && this.evidence.request !== this.automatedRequest)
+            || (this.evidence.submitIndex >= 0 && !this.evidence.settled && this.evidence.abortIndex < 0)
+            || [...this.requestRisks].some((risk) => risk());
+    }
     constructor(opts) {
         this.launchId = opts.launchId;
         this.sessionId = opts.sessionId;
@@ -305,16 +347,27 @@ export class CopilotLaunchRegistration {
         this.broker = opts.broker;
     }
     get eventCount() {
-        return this.events.length;
+        return this.state.events.length;
     }
     ownsConnection(socket) {
         return !this.disposed && !this.failed && this.activeConnection?.socket === socket;
     }
     isConnectionDraining(socket) {
-        return this.activeConnection?.socket === socket && this.activeConnection.drain !== undefined;
+        return this.activeConnection?.socket === socket
+            && this.activeConnection.committed === true && this.activeConnection.drain !== undefined;
+    }
+    isConnectionBackpressured(socket) {
+        const connection = this.activeConnection;
+        if (connection?.socket !== socket || !connection.drain)
+            return false;
+        // Parse received chunks even under pressure, but pause further reads until
+        // reductions catch up. A partial frame must remain able to receive its end.
+        return connection.committed === true
+            || connection.bufferedEvents.length - Math.max(connection.bufferedCursor, connection.admissionEnd ?? 0)
+                >= COPILOT_OBSERVER_WORK_QUANTUM;
     }
     snapshotEvents(startIndex = 0) {
-        return this.events.slice(startIndex);
+        return this.state.events.slice(startIndex);
     }
     snapshotDiagnostics() {
         const connection = this.activeConnection;
@@ -333,13 +386,22 @@ export class CopilotLaunchRegistration {
             currentEpoch: connection?.epoch ?? 0,
             epochCount: this.epochCount,
             replacementCount: Math.max(0, this.epochCount - 1),
-            recovering: this.recoveryCause !== undefined,
+            recovering: this.recoveryCause !== undefined && !this.failed && !this.disposed,
+            ...(this.lastRecoveryMode && { recoveryMode: this.lastRecoveryMode }),
+            recoveryBoundaryStatus: !this.state.watermark ? "absent"
+                : this.recoveryBoundaryStatus,
+            ...(this.recoveryRejection && { recoveryRejection: {
+                    ...this.recoveryRejection,
+                    ...(this.recoveryRejection.event && { event: { ...this.recoveryRejection.event } }),
+                } }),
+            ...(this.continuityProblem && { continuityProblem: this.continuityProblem }),
+            ...(this.startupVerificationProblem && { startupVerificationProblem: this.startupVerificationProblem }),
             connectionAttemptCount: this.connectionAttemptCount,
             rejectedDuplicateCount: this.rejectedDuplicateCount,
-            lifecycleEventCount: this.lifecycleEventCount,
-            eventCount: this.events.length,
+            lifecycleEventCount: this.state.lifecycleEventCount,
+            eventCount: this.eventCount,
             lastEventSeq: connection ? connection.nextSeq - 1 : 0,
-            eventTail: diagnosticEventTail(this.events),
+            eventTail: diagnosticEventTail(this.state.events),
             disposed: this.disposed,
             ...(this.workspacePath && { workspacePath: this.workspacePath }),
             ...(this.recoveryDeadlineAt !== undefined && { recoveryDeadlineAt: this.recoveryDeadlineAt }),
@@ -347,7 +409,7 @@ export class CopilotLaunchRegistration {
             ...(this.failed && { failureReason: this.failed.message }),
         };
     }
-    authenticate(message, socket) {
+    authenticate(message, socket, hasPendingIngress = () => false) {
         this.connectionAttemptCount++;
         if (this.disposed) {
             return {
@@ -382,8 +444,13 @@ export class CopilotLaunchRegistration {
             };
         }
         this.consumed = true;
+        const recovery = this.state.watermark
+            ? { mode: "suffix", afterEventId: this.state.watermark }
+            : this.mayHaveExecutingRequest() ? { mode: "uncertain" } : { mode: "live-only" };
+        this.lastRecoveryMode = recovery.mode;
         this.activeConnection = {
             socket,
+            hasPendingIngress,
             epoch: ++this.epochCount,
             nextSeq: 1,
             subscriptionReady: false,
@@ -393,10 +460,11 @@ export class CopilotLaunchRegistration {
             bufferedCursor: 0,
             bufferedChars: 0,
             extensionPath: message.extensionPath,
+            recovery,
         };
         return {
             accepted: true,
-            replayHistory: this.events.length > 0,
+            recovery,
             ...(this.excludeInheritedHistory && !this.inheritedEventIds && { captureHistoryBaseline: true }),
         };
     }
@@ -558,7 +626,7 @@ export class CopilotLaunchRegistration {
         if (this.failed)
             return;
         this.failed = error;
-        this.clearRecovery();
+        this.stopRecoveryTimer();
         const connection = this.activeConnection;
         this.activeConnection = undefined;
         if (connection?.drain)
@@ -585,7 +653,7 @@ export class CopilotLaunchRegistration {
         this.disposed = true;
         this.broker.unregisterLaunch(this);
         const disposedError = new Error("Copilot observer disposed");
-        this.clearRecovery();
+        this.stopRecoveryTimer();
         for (const waiter of this.readyWaiters) {
             if (waiter.timer)
                 clearTimeout(waiter.timer);
@@ -617,6 +685,21 @@ export class CopilotLaunchRegistration {
             return;
         }
         connection.nextSeq++;
+        if (message.origin === "history") {
+            if (connection.recovery.mode !== "suffix" || !connection.recoveryStarted
+                || connection.recoveryComplete || connection.liveSuffixStarted
+                || !durableEventId(message)) {
+                this.fail(new Error("Copilot observer received history outside a verified recovery suffix"));
+                return;
+            }
+            if (message.event.id === connection.recovery.afterEventId) {
+                this.fail(new Error("Copilot observer recovery included its excluded watermark"));
+                return;
+            }
+        }
+        else if (connection.recoveryStarted) {
+            connection.liveSuffixStarted = true;
+        }
         const eventId = stringProp(message.event, "id");
         if (eventId && this.inheritedEventIds?.has(eventId))
             return;
@@ -625,18 +708,59 @@ export class CopilotLaunchRegistration {
             this.fail(new Error(historyPayloadError));
             return;
         }
-        connection.bufferedEvents.push(message.event);
+        connection.bufferedEvents.push(message);
         connection.bufferedChars += JSON.stringify(message.event).length;
         if (connection.bufferedEvents.length - connection.bufferedCursor > OBSERVER_MAX_TENTATIVE_EVENTS
             || connection.bufferedChars > OBSERVER_MAX_PENDING_CHARS) {
             this.fail(new Error("Copilot observer readiness buffer exceeds the transport resource limit"));
             return;
         }
-        if (!this.updateLifecycle(message.event, connection))
+        if (message.origin === "live" && !this.updateLifecycle(message.event, connection))
             return;
         this.resolveReadyIfPossible(connection);
     }
     acceptControl(message, connection) {
+        if (message.type === "lifecycle.unverified") {
+            this.startupVerificationProblem = message.error || "Startup lifecycle durability was not verified";
+            return;
+        }
+        if (message.type === "recovery.error") {
+            this.continuityProblem = message.error || "SDK history boundary is unavailable";
+            if (message.recoveryRejection)
+                this.recordRecoveryRejection(message.recoveryRejection);
+            else
+                this.recoveryBoundaryStatus = connection.recoveryBoundary ? "established" : "unknown";
+            this.startRecovery(this.disconnectCause(connection, undefined));
+            this.disconnect(connection.socket);
+            connection.socket.destroy();
+            return;
+        }
+        if (message.type === "recovery.begin" || message.type === "recovery.end") {
+            if (connection.recovery.mode !== "suffix"
+                || message.afterEventId !== connection.recovery.afterEventId
+                || connection.subscriptionReady
+                || (message.type === "recovery.begin" ? connection.recoveryStarted
+                    : !connection.recoveryStarted || connection.recoveryComplete)) {
+                this.fail(new Error("Copilot observer reported an invalid recovery boundary"));
+                return;
+            }
+            if (message.type === "recovery.begin") {
+                connection.recoveryStarted = true;
+                connection.recoveryBoundary = message.event;
+            }
+            else
+                connection.recoveryComplete = true;
+            return;
+        }
+        if (message.type === "session.lifecycle") {
+            if (!message.event || (message.event.type !== "session.start" && message.event.type !== "session.resume")) {
+                this.fail(new Error("Copilot observer reported invalid live lifecycle evidence"));
+                return;
+            }
+            this.updateLifecycle(message.event, connection);
+            this.resolveReadyIfPossible(connection);
+            return;
+        }
         if (message.type === "inquiry.history_baseline") {
             if (!this.excludeInheritedHistory || this.inheritedEventIds || connection.inheritedEventIds
                 || !connection.joinedSessionReady || connection.subscriptionReady
@@ -650,7 +774,13 @@ export class CopilotLaunchRegistration {
             return;
         }
         if (message.type === "subscription.ready") {
+            if (connection.recovery.mode === "uncertain"
+                || (connection.recovery.mode === "suffix" && !connection.recoveryComplete)) {
+                this.fail(new Error("Copilot observer subscription preceded recovery reconciliation"));
+                return;
+            }
             connection.subscriptionReady = true;
+            connection.admissionEnd ??= connection.bufferedEvents.length;
             this.resolveReadyIfPossible(connection);
             return;
         }
@@ -705,7 +835,7 @@ export class CopilotLaunchRegistration {
     resolveReadyIfPossible(connection) {
         if (connection !== this.activeConnection || !this.isConnectionAdmitted(connection))
             return;
-        if (connection.bufferedCursor < connection.bufferedEvents.length) {
+        if (!connection.committed || connection.bufferedCursor < connection.bufferedEvents.length) {
             connection.drain ??= setImmediate(() => this.flushConnectionEventsIfReady(connection));
             return;
         }
@@ -714,11 +844,11 @@ export class CopilotLaunchRegistration {
             this.inheritedEventIds = connection.inheritedEventIds;
         }
         this.readyIdentityValue = ready;
-        this.clearRecovery();
         if (connection.closed) {
             this.disconnect(connection.socket, connection.closed.cause);
             return;
         }
+        this.clearRecovery();
         for (const waiter of this.readyWaiters) {
             if (waiter.timer)
                 clearTimeout(waiter.timer);
@@ -744,49 +874,100 @@ export class CopilotLaunchRegistration {
     }
     isConnectionReady(connection) {
         return this.isConnectionAdmitted(connection)
+            && connection.committed === true
             && connection.bufferedCursor === connection.bufferedEvents.length && !connection.drain;
     }
     isConnectionAdmitted(connection) {
         return connection.subscriptionReady && connection.joinedSessionReady && connection.lifecycleReady
+            && connection.recovery.mode !== "uncertain"
+            && (connection.recovery.mode !== "suffix" || connection.recoveryComplete === true)
             && (!this.excludeInheritedHistory || this.inheritedEventIds !== undefined || connection.inheritedEventIds !== undefined);
     }
     flushConnectionEventsIfReady(connection) {
         connection.drain = undefined;
         if (connection !== this.activeConnection || !this.isConnectionAdmitted(connection))
             return;
-        const end = Math.min(connection.bufferedEvents.length, connection.bufferedCursor + COPILOT_OBSERVER_WORK_QUANTUM);
-        while (connection.bufferedCursor < end && connection === this.activeConnection) {
-            const event = connection.bufferedEvents[connection.bufferedCursor++];
-            const id = stringProp(event, "id");
-            if (id)
-                connection.inheritedEventIds?.delete(id);
-            this.commitEvent(event);
-        }
-        if (connection.bufferedCursor === connection.bufferedEvents.length) {
+        if (!connection.committed) {
+            connection.transaction ??= this.prepareActivation(connection);
+            for (let i = 0; i < COPILOT_OBSERVER_WORK_QUANTUM; i++) {
+                let next;
+                try {
+                    next = connection.transaction.next();
+                }
+                catch (error) {
+                    if (!(error instanceof CopilotRecoveryOrderError))
+                        throw error;
+                    this.continuityProblem = error.message;
+                    this.recordRecoveryRejection(error.rejection);
+                    this.startRecovery(this.disconnectCause(connection, undefined));
+                    this.disconnect(connection.socket);
+                    connection.socket.destroy();
+                    return;
+                }
+                if (!next.done)
+                    continue;
+                // Host receipts are deliberately outside the draft. A concurrent write
+                // cannot make a previously safe live-only attachment safe to publish.
+                if (connection.recovery.mode === "live-only" && this.mayHaveExecutingRequest()) {
+                    this.continuityProblem = "A request may have started without a durable recovery watermark";
+                    this.startRecovery(this.disconnectCause(connection, undefined));
+                    this.disconnect(connection.socket);
+                    connection.socket.destroy();
+                    return;
+                }
+                this.state = next.value;
+                connection.transaction = undefined;
+                connection.committed = true;
+                break;
+            }
+        }
+        else {
+            const end = Math.min(connection.bufferedEvents.length, connection.bufferedCursor + COPILOT_OBSERVER_WORK_QUANTUM);
+            while (connection.bufferedCursor < end) {
+                this.state.accept(connection.bufferedEvents[connection.bufferedCursor++], this.sessionId, this.automatedRequest);
+            }
+        }
+        if (connection.committed && connection.bufferedCursor === connection.bufferedEvents.length) {
             connection.bufferedEvents = [];
             connection.bufferedCursor = 0;
             connection.bufferedChars = 0;
         }
         this.resolveReadyIfPossible(connection);
-    }
-    commitEvent(event) {
-        if (event.type === "session.start" || event.type === "session.resume") {
-            this.lifecycleEventCount++;
+        if (connection.committed && !connection.drain) {
+            const last = this.state.events.at(-1);
+            if (last)
+                for (const handler of this.eventHandlers)
+                    handler(last);
+        }
+    }
+    *prepareActivation(connection) {
+        const draft = yield* this.state.copy();
+        if (connection.recovery.mode === "suffix") {
+            const end = connection.admissionEnd;
+            const recovered = yield* reconcileRecoveryEvents(connection.bufferedEvents, end, connection.recovery.afterEventId, this.state.watermarkEvent, connection.recoveryBoundary);
+            for (const message of recovered) {
+                draft.accept(message, this.sessionId, this.automatedRequest);
+                yield;
+            }
+            // Ingress keeps appending to the original queue while the draft yields.
+            // Only the sealed admission prefix was reconciled; never replace that queue.
+            connection.bufferedCursor = end;
+        }
+        for (;;) {
+            while (connection.bufferedCursor < connection.bufferedEvents.length) {
+                const message = connection.bufferedEvents[connection.bufferedCursor++];
+                const id = stringProp(message.event, "id");
+                if (id)
+                    connection.inheritedEventIds?.delete(id);
+                draft.accept(message, this.sessionId, this.automatedRequest);
+                yield;
+            }
+            // The transport parser also yields. An empty event queue is not a
+            // publication barrier while received frames still await parsing.
+            if (!connection.hasPendingIngress())
+                return draft;
+            yield;
         }
-        const eventId = eventStableId(event);
-        const replayKey = eventReplayKey(event);
-        if (eventId && this.seenEventIds.has(eventId))
-            return;
-        if (replayKey && this.seenEventReplayKeys.has(replayKey))
-            return;
-        if (eventId)
-            this.seenEventIds.add(eventId);
-        if (replayKey)
-            this.seenEventReplayKeys.add(replayKey);
-        this.events.push(event);
-        this.evidence.accept(event, this.events.length - 1, this.sessionId);
-        for (const handler of this.eventHandlers)
-            handler(event);
     }
     flushPendingRpcs() {
         for (const requestId of this.pendingRpcs.keys()) {
@@ -816,15 +997,29 @@ export class CopilotLaunchRegistration {
         this.recoveryDeadlineAt = Date.now() + this.observerReadinessTimeoutMs;
         this.recoveryTimer = setTimeout(() => {
             this.recoveryTimer = undefined;
-            this.fail(this.recoveryCause ?? cause);
+            const original = this.recoveryCause ?? cause;
+            this.fail(this.continuityProblem
+                ? new Error(`Copilot observation continuity uncertain for session ${this.sessionId} (launch ${this.launchId}): ${this.continuityProblem}; ${original.message}`, { cause: original })
+                : original);
         }, Math.max(0, this.recoveryDeadlineAt - Date.now()));
     }
     clearRecovery() {
+        this.stopRecoveryTimer();
+        this.recoveryCause = undefined;
+        this.continuityProblem = undefined;
+        this.recoveryBoundaryStatus = "established";
+        this.recoveryRejection = undefined;
+        this.recoveryDeadlineAt = undefined;
+    }
+    stopRecoveryTimer() {
         if (this.recoveryTimer)
             clearTimeout(this.recoveryTimer);
         this.recoveryTimer = undefined;
-        this.recoveryCause = undefined;
-        this.recoveryDeadlineAt = undefined;
+    }
+    recordRecoveryRejection(rejection) {
+        this.recoveryRejection = rejection;
+        this.recoveryBoundaryStatus = rejection.boundary === "located" ? "established"
+            : rejection.boundary === "missing" || rejection.boundary === "untrustworthy" ? "unavailable" : "unknown";
     }
     disconnectCause(connection, cause) {
         if (cause)
@@ -839,6 +1034,147 @@ export class CopilotLaunchRegistration {
         return samePath(dirname(extensionPath), this.preferredExtensionDir);
     }
 }
+class CopilotRecoveryOrderError extends Error {
+    rejection;
+    constructor(message, rejection) {
+        super(message);
+        this.rejection = rejection;
+    }
+}
+/** Canonical history orders overlap; parent evidence precedes surrounding-match fallback. */
+function* reconcileRecoveryEvents(events, end, watermark, watermarkEvent, boundaryRecord) {
+    if (watermarkEvent && boundaryRecord && !matchesHistoryEvidence(watermarkEvent, boundaryRecord)) {
+        throw new CopilotRecoveryOrderError("SDK history conflicts with the committed watermark record", {
+            stage: "reconciliation", boundary: "untrustworthy",
+            event: describeRecoveryEvent(boundaryRecord, "history", new Map([[watermark, -1]])),
+        });
+    }
+    const history = [];
+    const live = [];
+    const historyPositions = new Map([[watermark, -1]]);
+    const callbackPositions = new Map();
+    const records = new Map();
+    if (watermarkEvent)
+        records.set(watermark, watermarkEvent);
+    const planTools = new Map();
+    const recordPlanTools = (event, position) => {
+        const tools = recordProp(event, "data")?.toolRequests;
+        if (Array.isArray(tools))
+            for (const tool of tools) {
+                if (isRecord(tool) && tool.name === "exit_plan_mode") {
+                    const id = stringProp(tool, "toolCallId");
+                    if (id)
+                        planTools.set(id, position);
+                }
+            }
+    };
+    if (watermarkEvent)
+        recordPlanTools(watermarkEvent, -1);
+    const reject = (reason, message, boundary = "located") => new CopilotRecoveryOrderError(reason, {
+        stage: "reconciliation", boundary,
+        event: describeRecoveryEvent(message.event, message.origin, historyPositions, callbackPositions),
+    });
+    for (let i = 0; i < end; i++) {
+        const message = events[i];
+        if (message.origin === "history") {
+            const id = stringProp(message.event, "id");
+            if (!id || historyPositions.has(id))
+                throw reject("SDK history has ambiguous durable event identities", message, "untrustworthy");
+            historyPositions.set(id, history.length);
+            records.set(id, message.event);
+            recordPlanTools(message.event, history.length);
+            history.push(message);
+        }
+        else {
+            live.push(message);
+        }
+        yield;
+    }
+    for (let i = 0; i < history.length; i++) {
+        const parent = historyPositions.get(stringProp(history[i].event, "parentId") ?? "");
+        if (parent !== undefined && parent >= i)
+            throw reject("SDK history has an inconsistent event order", history[i], "untrustworthy");
+        yield;
+    }
+    const followingMatches = new Array(live.length);
+    for (const message of live) {
+        const id = stringProp(message.event, "id");
+        const record = id ? records.get(id) : undefined;
+        if (record && !matchesHistoryEvidence(message.event, record)) {
+            throw reject("SDK callback conflicts with its durable history record", message);
+        }
+        if (id)
+            callbackPositions.set(id, 0);
+        yield;
+    }
+    // Validation tracked availability only; placement rebuilds supported ancestry.
+    callbackPositions.clear();
+    let following;
+    for (let i = live.length - 1; i >= 0; i--) {
+        followingMatches[i] = following;
+        const id = stringProp(live[i].event, "id");
+        following = (id ? historyPositions.get(id) : undefined) ?? following;
+        yield;
+    }
+    const slots = new Map();
+    let preceding;
+    for (let i = 0; i < live.length; i++) {
+        const message = live[i];
+        const event = message.event;
+        const id = stringProp(event, "id");
+        const historyPosition = id ? historyPositions.get(id) : undefined;
+        if (historyPosition !== undefined) {
+            preceding = historyPosition;
+            yield;
+            continue;
+        }
+        const record = id ? records.get(id) : undefined;
+        if (record) {
+            if (!matchesHistoryEvidence(event, record)) {
+                throw reject("SDK callback conflicts with an earlier callback record", message);
+            }
+            yield;
+            continue;
+        }
+        const parentId = stringProp(event, "parentId");
+        const parent = message.origin === "bridge" && message.toolCallId
+            ? planTools.get(message.toolCallId)
+            : historyPositions.get(parentId ?? "") ?? callbackPositions.get(parentId ?? "");
+        const lifecycle = event.type === "session.start" || event.type === "session.resume";
+        const telemetry = isModelTelemetry(event);
+        const next = followingMatches[i];
+        let slot = preceding !== undefined && next !== undefined ? Math.min(preceding, next) + 1
+            : preceding !== undefined ? preceding + 1
+                : next !== undefined ? Math.max(0, next) : history.length;
+        const transient = event.ephemeral === true || message.origin === "bridge"
+            || event.type === "session.idle" || isAbortEvent(event);
+        if (!lifecycle && !telemetry) {
+            if (parent !== undefined)
+                slot = parent + 1;
+        }
+        const bucket = slots.get(slot) ?? [];
+        bucket.push(transient || lifecycle || telemetry ? { ...message, transient: true } : message);
+        slots.set(slot, bucket);
+        if (!lifecycle && !telemetry && id) {
+            callbackPositions.set(id, slot - 1);
+            records.set(id, event);
+            recordPlanTools(event, slot - 1);
+        }
+        yield;
+    }
+    const reconciled = [];
+    for (let i = 0; i <= history.length; i++) {
+        for (const message of slots.get(i) ?? []) {
+            reconciled.push(message);
+            yield;
+        }
+        if (i < history.length) {
+            reconciled.push(history[i]);
+            yield;
+        }
+    }
+    return reconciled;
+}
 export function copilotObserverPluginIdentityForLaunchId(launchId) {
     const compactId = launchId.toLowerCase().replace(/-/g, "");
     const identity = `${OBSERVER_PLUGIN_IDENTITY_PREFIX}-${compactId}`;
@@ -861,6 +1197,7 @@ export class CopilotProcessObserver {
     args;
     env;
     disposed = false;
+    disposePromise;
     composer = new CopilotComposerInspector();
     constructor(broker, registration, tempRoot, pluginDir, pluginIdentity, extensionDir, sessionExtensionDir, sdkPath, sdkEntryPath, ownsBroker, ownsTempRoot, onDispose) {
         this.broker = broker;
@@ -896,22 +1233,24 @@ export class CopilotProcessObserver {
         const broker = await CopilotObservationBroker.start();
         try {
             const sdkAssets = await resolveCopilotObserverSdkAssets();
-            return await CopilotProcessObserver.createWithResources(broker, sdkAssets, sessionId, true, opts.excludeInheritedHistory);
+            return await CopilotProcessObserver.createWithResources(broker, sdkAssets, sessionId, true, opts.excludeInheritedHistory, undefined, opts.prompt);
         }
         catch (err) {
-            await broker.close();
+            await cleanupResources([() => broker.close()], { error: err });
             throw err;
         }
     }
     static async createWithSharedBroker(broker, sdkAssets, opts, onDispose) {
         const sessionId = requiredCopilotObserverSessionId(opts);
-        return CopilotProcessObserver.createWithResources(broker, sdkAssets, sessionId, false, opts.excludeInheritedHistory, onDispose);
+        return CopilotProcessObserver.createWithResources(broker, sdkAssets, sessionId, false, opts.excludeInheritedHistory, onDispose, opts.prompt);
     }
-    static async createWithResources(broker, sdkAssets, sessionId, ownsBroker, excludeInheritedHistory = false, onDispose) {
+    static async createWithResources(broker, sdkAssets, sessionId, ownsBroker, excludeInheritedHistory = false, onDispose, prompt = "") {
         let pluginAssets;
         let registration;
         try {
             registration = broker.registerLaunch(sessionId);
+            if (prompt)
+                registration.prepareRequest(prompt);
             if (excludeInheritedHistory)
                 registration.requireInheritedHistoryBoundary();
             const pluginIdentity = copilotObserverPluginIdentityForLaunchId(registration.launchId);
@@ -920,10 +1259,10 @@ export class CopilotProcessObserver {
             return new CopilotProcessObserver(broker, registration, pluginAssets.tempRoot, pluginAssets.pluginDir, pluginAssets.pluginIdentity, pluginAssets.extensionDir, pluginAssets.sessionExtensionDir, sdkAssets.sdkPath, sdkAssets.sdkEntryPath, ownsBroker, true, onDispose);
         }
         catch (err) {
-            registration?.dispose();
-            if (pluginAssets) {
-                await cleanupCopilotObserverPluginAssets(pluginAssets);
-            }
+            await cleanupResources([
+                () => registration?.dispose(),
+                () => pluginAssets ? cleanupCopilotObserverPluginAssets(pluginAssets) : undefined,
+            ], { error: err });
             throw err;
         }
     }
@@ -937,6 +1276,10 @@ export class CopilotProcessObserver {
         return this.registration.waitForReady(opts);
     }
     async submitPrompt(target, prompt, opts = {}) {
+        const existing = this.registration.requestForDetector();
+        const request = existing && !existing.written
+            ? existing : this.registration.prepareRequest(prompt);
+        request.prompt = prompt;
         await this.registration.waitForUsableConnection({ signal: opts.signal });
         await sendComposerText(target, prompt, this.composer, {
             signal: opts.signal,
@@ -944,6 +1287,7 @@ export class CopilotProcessObserver {
             beforeSubmit: async () => {
                 await this.registration.waitForUsableConnection({ signal: opts.signal });
             },
+            onSubmitWritten: () => { request.written = true; },
         });
     }
     createDetector(opts) {
@@ -965,25 +1309,24 @@ export class CopilotProcessObserver {
             sdkPath: this.sdkPath,
         };
     }
-    async dispose() {
-        if (this.disposed)
-            return;
+    dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
         this.disposed = true;
-        this.onDispose?.(this);
-        this.registration.dispose();
-        if (this.ownsBroker)
-            await this.broker.close();
-        await Promise.all([
-            this.ownsTempRoot
-                ? rm(this.tempRoot, { recursive: true, force: true }).catch(() => { })
-                : Promise.resolve(),
-            rm(this.sessionExtensionDir, { recursive: true, force: true }).catch(() => { }),
+        this.disposePromise = cleanupResources([
+            () => this.registration.dispose(),
+            () => this.ownsBroker ? this.broker.close() : undefined,
+            () => this.ownsTempRoot ? rm(this.tempRoot, { recursive: true, force: true }) : undefined,
+            () => rm(this.sessionExtensionDir, { recursive: true, force: true }),
+            () => this.onDispose?.(this),
         ]);
+        return this.disposePromise;
     }
 }
 export class CopilotObserverRun {
     provider = "copilot";
     disposed = false;
+    disposePromise;
     observers = new Set();
     sharedResourcesValue;
     sharedResourcesPromise;
@@ -1005,25 +1348,30 @@ export class CopilotObserverRun {
         this.observers.add(observer);
         return observer;
     }
-    async dispose() {
-        if (this.disposed)
-            return;
+    dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
         this.disposed = true;
         const observers = [...this.observers];
         this.observers.clear();
-        await Promise.all(observers.map((observer) => observer.dispose()));
-        let resources = this.sharedResourcesValue;
-        if (this.sharedResourcesPromise) {
-            try {
-                resources = await this.sharedResourcesPromise;
-            }
-            catch {
-                // Initialization failure is reported to the launch caller.
-            }
-        }
-        this.sharedResourcesValue = undefined;
-        this.sharedResourcesPromise = undefined;
-        await resources?.broker.close();
+        this.disposePromise = cleanupResources([
+            ...observers.map((observer) => () => observer.dispose()),
+            async () => {
+                let resources = this.sharedResourcesValue;
+                if (this.sharedResourcesPromise) {
+                    try {
+                        resources = await this.sharedResourcesPromise;
+                    }
+                    catch {
+                        // Initialization failure is reported to the launch caller.
+                    }
+                }
+                this.sharedResourcesValue = undefined;
+                this.sharedResourcesPromise = undefined;
+                await resources?.broker.close();
+            },
+        ]);
+        return this.disposePromise;
     }
     sharedResources() {
         if (this.disposed) {
@@ -1058,7 +1406,7 @@ export class CopilotObserverRun {
             return resources;
         }
         catch (err) {
-            await broker.close();
+            await cleanupResources([() => broker.close()], { error: err });
             throw err;
         }
     }
@@ -1092,10 +1440,10 @@ async function prepareCopilotObserverPluginAssets(pluginIdentity, launchId, sess
         };
     }
     catch (err) {
-        await Promise.allSettled([
-            rm(tempRoot, { recursive: true, force: true }),
-            rm(sessionExtensionDir, { recursive: true, force: true }),
-        ]);
+        await cleanupResources([
+            () => rm(tempRoot, { recursive: true, force: true }),
+            () => rm(sessionExtensionDir, { recursive: true, force: true }),
+        ], { error: err });
         throw err;
     }
 }
@@ -1153,9 +1501,9 @@ function copilotObserverSessionExtensionDir(sessionId, pluginIdentity) {
     return join(getCopilotSessionDir(), sessionId, "extensions", pluginIdentity);
 }
 async function cleanupCopilotObserverPluginAssets(assets) {
-    await Promise.all([
-        rm(assets.tempRoot, { recursive: true, force: true }).catch(() => { }),
-        rm(assets.sessionExtensionDir, { recursive: true, force: true }).catch(() => { }),
+    await cleanupResources([
+        () => rm(assets.tempRoot, { recursive: true, force: true }),
+        () => rm(assets.sessionExtensionDir, { recursive: true, force: true }),
     ]);
 }
 function assertValidCopilotObserverPluginIdentity(identity) {
@@ -1186,7 +1534,7 @@ function sendAuthResult(socket, decision) {
         ? {
             kind: "auth.result",
             accepted: true,
-            ...(decision.replayHistory && { replayHistory: true }),
+            recovery: decision.recovery,
             ...(decision.captureHistoryBaseline && { captureHistoryBaseline: true }),
         }
         : { kind: "auth.result", accepted: false, reason: decision.reason };
@@ -1202,6 +1550,75 @@ function requiredCopilotObserverSessionId(opts) {
 function disposedCopilotObserverRunError() {
     return new Error("Copilot observer run has been disposed");
 }
+/** State and durable progress are published together, never from a draft prefix. */
+class CopilotObservationState {
+    events = [];
+    seenEventIds = new Set();
+    seenEventReplayKeys = new Set();
+    evidence = new CopilotLiveEvidence();
+    watermark;
+    watermarkEvent;
+    lifecycleEventCount = 0;
+    *copy() {
+        const copy = new CopilotObservationState();
+        copy.watermark = this.watermark;
+        copy.watermarkEvent = this.watermarkEvent;
+        copy.lifecycleEventCount = this.lifecycleEventCount;
+        for (const event of this.events) {
+            copy.events.push(event);
+            yield;
+        }
+        for (const id of this.seenEventIds) {
+            copy.seenEventIds.add(id);
+            yield;
+        }
+        for (const key of this.seenEventReplayKeys) {
+            copy.seenEventReplayKeys.add(key);
+            yield;
+        }
+        copy.evidence = yield* this.evidence.copy();
+        return copy;
+    }
+    accept(message, sessionId, request) {
+        const event = message.event;
+        if (event.type === "session.start" || event.type === "session.resume")
+            this.lifecycleEventCount++;
+        const id = eventStableId(event);
+        const key = eventReplayKey(event);
+        if (id && this.seenEventIds.has(id))
+            return;
+        const duplicate = key !== undefined && this.seenEventReplayKeys.has(key);
+        if (id)
+            this.seenEventIds.add(id);
+        if (key)
+            this.seenEventReplayKeys.add(key);
+        if (!duplicate) {
+            this.events.push(event);
+            this.evidence.accept(event, this.events.length - 1, sessionId, request, message);
+        }
+        // A semantic alias can be skipped, but only its genuine durable ID is progress.
+        const durableId = durableEventId(message);
+        if (durableId && (message.origin === "live" || this.watermark)) {
+            this.watermark = durableId;
+            this.watermarkEvent = event;
+        }
+    }
+}
+function durableEventId(message) {
+    if (message.origin === "bridge" || message.transient || message.event.ephemeral === true
+        || isModelTelemetry(message.event))
+        return undefined;
+    if (message.origin === "live"
+        && (message.event.type === "session.start" || message.event.type === "session.resume")
+        && message.lifecycleDurability !== "sdk-history")
+        return undefined;
+    return stringProp(message.event, "id");
+}
+function isModelTelemetry(event) {
+    // SDK model tracing is a separate, non-persisted graph, including unflagged
+    // title-generation callbacks. It supplies neither progress nor turn evidence.
+    return typeof event.type === "string" && event.type.startsWith("model.");
+}
 /** Launch-local authority. Snapshots/materialized output are explicit operations. */
 class CopilotLiveEvidence {
     rewriteGeneration = 0;
@@ -1214,33 +1631,123 @@ class CopilotLiveEvidence {
     background = new CopilotBackgroundWorkState();
     boundary = new CopilotFinalBoundaryState();
     boundarySettled = false;
+    generation = 0;
+    request;
+    responseParts = [];
+    planExit;
+    turnId;
+    interactionId;
+    retiredTurnIds = new Set();
+    retiredInteractionIds = new Set();
+    exitTools = new Set();
+    *copy() {
+        const copy = Object.assign(new CopilotLiveEvidence(), this);
+        copy.submitIdentities = [];
+        for (const id of this.submitIdentities) {
+            copy.submitIdentities.push(id);
+            yield;
+        }
+        copy.responseParts = [];
+        for (const part of this.responseParts) {
+            copy.responseParts.push(part);
+            yield;
+        }
+        copy.retiredTurnIds = new Set();
+        for (const id of this.retiredTurnIds) {
+            copy.retiredTurnIds.add(id);
+            yield;
+        }
+        copy.retiredInteractionIds = new Set();
+        for (const id of this.retiredInteractionIds) {
+            copy.retiredInteractionIds.add(id);
+            yield;
+        }
+        copy.exitTools = new Set(this.exitTools);
+        copy.background = yield* this.background.copy();
+        copy.boundary = this.boundary.copy();
+        return copy;
+    }
     get submitCount() { return this.submitIdentities.length; }
     get settled() {
         return this.submitIndex >= 0 && ((this.boundary.latest !== undefined && this.boundarySettled)
             || (this.assistantIndex > this.submitIndex && this.idleIndex > this.assistantIndex));
     }
-    accept(event, index, sessionId) {
+    accept(event, index, sessionId, request, message) {
+        if (isModelTelemetry(event))
+            return;
         if (isLiveHistoryRewriteEvent(event)) {
             this.rewriteGeneration++;
             this.removedSubmitIdentities = this.submitIdentities;
             this.submitIdentities = [];
             this.resetTurn();
+            this.retiredInteractionIds.clear();
+            this.request = undefined;
             return;
         }
+        const data = recordProp(event, "data");
+        const turnId = stringProp(data, "turnId") ?? stringProp(event, "turnId")
+            ?? stringProp(recordProp(data, "input"), "turnId");
+        const interactionId = stringProp(data, "interactionId");
+        if (!isAgentScoped(event) && interactionId && this.retiredInteractionIds.has(interactionId))
+            return;
         if (isLiveRootSubmit(event)) {
+            if (this.interactionId && this.interactionId !== interactionId) {
+                this.retiredInteractionIds.add(this.interactionId);
+            }
             this.resetTurn();
+            this.turnId = turnId;
+            this.interactionId = interactionId;
             this.submitIndex = index;
             this.submitIdentities.push(liveSubmitIdentity(event, index, this.rewriteGeneration));
+            if (request?.written && normalizePrompt(stringProp(data, "content") ?? "") === normalizePrompt(request.prompt)) {
+                this.request = request;
+            }
+            else if (request !== this.request) {
+                this.request = undefined;
+            }
+        }
+        if (!isAgentScoped(event)) {
+            if (event.type === "assistant.turn_start" && this.submitIndex >= 0 && turnId
+                && !this.retiredTurnIds.has(turnId)
+                && (!interactionId || !this.interactionId || interactionId === this.interactionId)) {
+                if (this.turnId && this.turnId !== turnId)
+                    this.retiredTurnIds.add(this.turnId);
+                this.turnId = turnId;
+                this.interactionId ??= interactionId;
+            }
+            if ((turnId && this.retiredTurnIds.has(turnId))
+                || (turnId && this.turnId && turnId !== this.turnId)
+                || (interactionId && this.interactionId && interactionId !== this.interactionId))
+                return;
+            if (this.submitIndex >= 0) {
+                if (isAbortEvent(event))
+                    this.abortIndex = index;
+                if (event.type === "assistant.message") {
+                    const content = stringProp(data, "content");
+                    if (content) {
+                        this.assistantIndex = index;
+                        this.responseParts.push(content);
+                    }
+                    const tools = data?.toolRequests;
+                    if (Array.isArray(tools))
+                        for (const tool of tools) {
+                            if (isRecord(tool) && tool.name === "exit_plan_mode") {
+                                const id = stringProp(tool, "toolCallId");
+                                if (id)
+                                    this.exitTools.add(id);
+                                this.planExit = { generation: this.generation };
+                            }
+                        }
+                }
+                if (message?.origin === "bridge" && message.toolCallId && this.exitTools.has(message.toolCallId)) {
+                    this.planExit = { generation: this.generation, inline: nativePlanFromExitEvent(event) };
+                }
+                if (isSessionIdle(event, sessionId))
+                    this.idleIndex = index;
+            }
         }
-        if (isAbortEvent(event) && this.submitIndex >= 0)
-            this.abortIndex = index;
-        if (!isAgentScoped(event) && event.type === "assistant.message"
-            && stringProp(recordProp(event, "data"), "content"))
-            this.assistantIndex = index;
-        if (isSessionIdle(event, sessionId))
-            this.idleIndex = index;
         this.background.accept(event);
-        if (this.boundary.accept(event, index, sessionId)) {
+        if (this.submitIndex >= 0 && this.boundary.accept(event, index, sessionId)) {
             // Later background completion cannot validate an earlier stop.
             this.boundarySettled = this.background.size === 0;
         }
@@ -1262,6 +1769,14 @@ class CopilotLiveEvidence {
         };
     }
     resetTurn() {
+        this.generation++;
+        // A root submission owns its cycles even when the SDK omits interactionId.
+        this.retiredTurnIds.clear();
+        this.turnId = undefined;
+        this.interactionId = undefined;
+        this.responseParts = [];
+        this.planExit = undefined;
+        this.exitTools = new Set();
         this.submitIndex = -1;
         this.abortIndex = -1;
         this.assistantIndex = -1;
@@ -1271,7 +1786,10 @@ class CopilotLiveEvidence {
         this.boundarySettled = false;
     }
 }
-class CopilotLiveTurnMonitor {
+function normalizePrompt(prompt) {
+    return prompt.replace(/\r\n/g, "\n").trim().replace(/^\/plan\s+/, "");
+}
+export class CopilotLiveTurnMonitor {
     registration;
     opts;
     unsubscribeEvent;
@@ -1290,12 +1808,15 @@ class CopilotLiveTurnMonitor {
     historySnapshot;
     historyRevision;
     abort = new AbortController();
+    untrackRequestRisk;
+    unresolvedAttempt;
     constructor(registration, opts = {}) {
         this.registration = registration;
         this.opts = opts;
         this.attemptTimeoutMs = opts.attemptTimeoutMs ?? 5_000;
         this.historySnapshot = opts.initialHistorySnapshot;
         this.refreshCounts();
+        this.untrackRequestRisk = registration.trackRequestRisk(() => this.hasUnconfirmedInput());
         this.unsubscribeEvent = registration.onEvent(() => this.onEvent());
         this.unsubscribeError = registration.onError((error) => {
             if (this.stopped)
@@ -1306,7 +1827,14 @@ class CopilotLiveTurnMonitor {
         });
     }
     get isIdle() {
-        return !this.busy;
+        return this.registration.continuityAvailable && !this.busy && !this.hasUnconfirmedInput();
+    }
+    hasUnconfirmedInput() {
+        this.refreshAttemptRisk();
+        const count = this.registration.evidence.submitCount;
+        return this.unresolvedAttempt !== undefined
+            || [...this.entries.values()].some((entry) => entry.receipt.inputWritten
+                && (entry.ordinal === undefined || entry.ordinal > count));
     }
     get lineBaseline() {
         return this.coveredSubmitCount;
@@ -1321,6 +1849,8 @@ class CopilotLiveTurnMonitor {
         this.reconcileLiveHistory();
     }
     reserveTurn(boundary = {}) {
+        this.reconcileLiveHistory();
+        this.refreshCounts();
         const receipt = new SessionTurnReceipt({
             ...boundary,
             anchorSubmitCount: boundary.anchorSubmitCount ?? this.observedSubmitCount,
@@ -1340,10 +1870,22 @@ class CopilotLiveTurnMonitor {
         }
     }
     attachTurn(receipt) {
-        if (this.stopped || this.attached.has(receipt) || receipt.settlement)
+        if (this.stopped || this.attached.has(receipt))
             return;
         this.attached.add(receipt);
-        const entry = { receipt };
+        this.reconcileLiveHistory();
+        this.refreshCounts();
+        if (receipt.rawAttempt && receipt.inputWritten && (!receipt.settlement || receipt.settlement === "expired")) {
+            this.unresolvedAttempt = {
+                submitFloor: Math.max(this.unresolvedAttempt?.submitFloor ?? -1, receipt.anchorSubmitCount ?? this.observedSubmitCount),
+                rewriteGeneration: this.registration.evidence.rewriteGeneration,
+            };
+        }
+        if (receipt.settlement)
+            return;
+        const entry = {
+            receipt, anchorSubmitCount: receipt.anchorSubmitCount ?? this.observedSubmitCount,
+        };
         this.entries.set(receipt.id, entry);
         entry.unsubscribe = receipt.onChange(() => {
             if (receipt.settlement === "released" && entry.ordinal === undefined) {
@@ -1351,8 +1893,12 @@ class CopilotLiveTurnMonitor {
                 this.evaluateSettlement();
             }
         });
-        if (receipt.inputWritten && !receipt.rawAttempt)
-            this.confirmTurn(entry);
+        if (receipt.inputWritten) {
+            if (receipt.rawAttempt)
+                this.trackRawAttempt(entry);
+            else
+                this.confirmTurn(entry);
+        }
     }
     beginTurn(receipt) {
         if (!receipt) {
@@ -1385,28 +1931,28 @@ class CopilotLiveTurnMonitor {
         this.evaluateSettlement();
     }
     beginTurnAttempt(snapshot = {}) {
+        this.reconcileLiveHistory();
+        this.refreshCounts();
         const receipt = new SessionTurnReceipt({
             ...snapshot,
             anchorSubmitCount: snapshot.anchorSubmitCount ?? this.observedSubmitCount,
         }, true);
         receipt.markWritten();
         this.attachTurn(receipt);
-        if (this.stopped)
-            return receipt;
+        return receipt;
+    }
+    trackRawAttempt(entry) {
+        const { receipt, anchorSubmitCount } = entry;
         this.refreshCounts();
-        const startedAt = snapshot.startedAt ?? Date.now();
-        const elapsed = Date.now() - startedAt;
+        const elapsed = Date.now() - receipt.startedAt;
         if (elapsed >= this.attemptTimeoutMs) {
             receipt.settle("expired");
-            const entry = this.entries.get(receipt.id);
-            if (entry)
-                this.removeEntry(entry);
+            this.removeEntry(entry);
             this.evaluateSettlement({ notifyIfAlreadyIdle: true });
-            return receipt;
+            return;
         }
         const attempt = {
-            anchorSubmitCount: snapshot.anchorSubmitCount ?? this.observedSubmitCount,
-            receipt,
+            anchorSubmitCount, receipt,
         };
         attempt.timer = setTimeout(() => {
             const index = this.pendingAttempts.indexOf(attempt);
@@ -1421,7 +1967,10 @@ class CopilotLiveTurnMonitor {
         }, Math.max(0, this.attemptTimeoutMs - elapsed));
         this.pendingAttempts.push(attempt);
         this.markBusy();
-        return receipt;
+        if (this.observedSubmitCount > anchorSubmitCount) {
+            this.adoptObservedSubmits(anchorSubmitCount);
+            this.evaluateSettlement();
+        }
     }
     waitForPendingTurnAttempts() {
         if (this.pendingAttempts.length === 0 || this.stopped)
@@ -1449,12 +1998,15 @@ class CopilotLiveTurnMonitor {
         this.refreshCounts();
         if (baseline < 0)
             return "unknown";
-        return this.observedSubmitCount > baseline ? "present" : "absent";
+        if (this.observedSubmitCount > baseline)
+            return "present";
+        return this.registration.continuityAvailable && !this.hasUnconfirmedInput() ? "absent" : "unknown";
     }
     dispose() {
         this.abort.abort(new Error("Copilot turn monitor disposed"));
         this.unsubscribeEvent();
         this.unsubscribeError();
+        this.untrackRequestRisk();
         for (const attempt of this.pendingAttempts) {
             if (attempt.timer)
                 clearTimeout(attempt.timer);
@@ -1479,8 +2031,24 @@ class CopilotLiveTurnMonitor {
         if (this.observedSubmitCount > previousObserved) {
             this.adoptObservedSubmits(previousObserved);
         }
+        this.adoptWrittenSubmits();
         this.evaluateSettlement();
     }
+    adoptWrittenSubmits() {
+        let previousOrdinal = 0;
+        for (const entry of this.entries.values()) {
+            if (entry.ordinal === undefined && entry.receipt.inputWritten && !entry.receipt.rawAttempt) {
+                const ordinal = Math.max(previousOrdinal + 1, entry.anchorSubmitCount + 1);
+                entry.anchorSubmitCount = ordinal - 1;
+                if (ordinal <= this.observedSubmitCount) {
+                    entry.ordinal = ordinal;
+                    this.highestOrdinal = Math.max(this.highestOrdinal, ordinal);
+                    this.expectedSubmitCount = Math.max(this.expectedSubmitCount, ordinal);
+                }
+            }
+            previousOrdinal = Math.max(previousOrdinal, entry.ordinal ?? entry.anchorSubmitCount + 1);
+        }
+    }
     adoptObservedSubmits(previousObserved) {
         for (let i = this.pendingAttempts.length - 1; i >= 0; i--) {
             const attempt = this.pendingAttempts[i];
@@ -1505,8 +2073,26 @@ class CopilotLiveTurnMonitor {
     }
     refreshCounts() {
         this.observedSubmitCount = this.registration.evidence.submitCount;
+        this.refreshAttemptRisk();
+    }
+    refreshAttemptRisk() {
+        const risk = this.unresolvedAttempt;
+        if (!risk)
+            return;
+        const evidence = this.registration.evidence;
+        if (risk.rewriteGeneration !== evidence.rewriteGeneration) {
+            // A validated rewrite resets the submit namespace, not proof of nondelivery.
+            // New input recorded in the committed generation must retain its own floor.
+            risk.submitFloor = 0;
+            risk.rewriteGeneration = evidence.rewriteGeneration;
+        }
+        if (evidence.submitCount > risk.submitFloor) {
+            this.unresolvedAttempt = undefined;
+        }
     }
     evaluateSettlement(options = {}) {
+        if (!this.registration.outcomesAvailable)
+            return;
         const evidence = this.registration.evidence;
         this.observedSubmitCount = evidence.submitCount;
         if (this.observedSubmitCount > this.coveredSubmitCount
@@ -1523,7 +2109,8 @@ class CopilotLiveTurnMonitor {
             }
         }
         if (this.coveredSubmitCount < this.expectedSubmitCount
-            || this.pendingAttempts.length > 0) {
+            || this.pendingAttempts.length > 0
+            || this.hasUnconfirmedInput()) {
             return;
         }
         const wasBusy = this.busy;
@@ -1568,6 +2155,7 @@ class CopilotLiveTurnMonitor {
             attempt.anchorSubmitCount = Math.min(attempt.anchorSubmitCount, regression.commonSubmitCount);
         }
         for (const entry of this.entries.values()) {
+            entry.anchorSubmitCount = Math.min(entry.anchorSubmitCount, regression.commonSubmitCount);
             if (entry.ordinal !== undefined && entry.ordinal > regression.commonSubmitCount) {
                 this.removeEntry(entry);
                 entry.receipt.settle("removed");
@@ -1607,14 +2195,15 @@ export class CopilotLiveCompletionDetector {
     markerTimer;
     resolve;
     reject;
-    startIndex = 0;
+    startGeneration = 0;
+    initialResponsePartCount = 0;
+    request;
     completed = false;
     activationFired = false;
     nativePlan;
     disposed = false;
-    readingPlan = false;
+    readingPlanGeneration;
     abort = new AbortController();
-    responseParts = [];
     constructor(registration, opts = {}) {
         this.registration = registration;
         this.opts = opts;
@@ -1622,13 +2211,16 @@ export class CopilotLiveCompletionDetector {
         if (opts.completionPolicy)
             this.completionGate = new FileAndTurnCompletionGate(opts.completionPolicy);
     }
-    start(_sessionFile, lineOffset = 0) {
-        this.startIndex = Math.max(this.registration.eventCount, lineOffset);
+    start(_sessionFile, _lineOffset = 0) {
+        this.startGeneration = this.registration.evidence.generation;
+        this.initialResponsePartCount = this.registration.evidence.responseParts.length;
+        this.request = this.registration.requestForDetector();
         return new Promise((resolve, reject) => {
             this.resolve = resolve;
             this.reject = reject;
-            this.unsubscribeEvent = this.registration.onEvent((event) => {
-                void this.onEvent(event);
+            this.unsubscribeEvent = this.registration.onEvent(() => {
+                this.fireActivationIfNeeded();
+                void this.evaluate();
             });
             this.unsubscribeError = this.registration.onError((error) => {
                 this.finishError(error);
@@ -1670,53 +2262,52 @@ export class CopilotLiveCompletionDetector {
     getCompletionDisposition() {
         return this.completionGate?.disposition;
     }
-    async onEvent(event) {
-        if (this.completed || this.disposed || this.registration.eventCount <= this.startIndex)
+    ownsCurrentRequest(generation = this.registration.evidence.generation) {
+        const evidence = this.registration.evidence;
+        return evidence.generation === generation && generation > this.startGeneration
+            && evidence.submitIndex >= 0 && (!this.request || evidence.request === this.request);
+    }
+    async evaluate() {
+        if (this.completed || this.disposed || !this.registration.outcomesAvailable)
+            return;
+        const evidence = this.registration.evidence;
+        const owned = this.ownsCurrentRequest();
+        if (owned && evidence.abortIndex >= 0) {
+            this.finishError(new Error("Copilot session aborted before completing the active turn"));
             return;
-        this.fireActivationIfNeeded();
-        if (isLiveRootSubmit(event) || isLiveHistoryRewriteEvent(event))
-            this.responseParts = [];
-        const data = recordProp(event, "data");
-        if (!isAgentScoped(event) && event.type === "assistant.message") {
-            const content = stringProp(data, "content");
-            if (content)
-                this.responseParts.push(content);
         }
-        if (this.opts.planMode && isExitPlanRequested(event)) {
-            if (this.readingPlan)
-                return;
-            const inlinePlan = nativePlanFromExitEvent(event);
+        if (owned && this.opts.planMode && evidence.planExit) {
+            const generation = evidence.generation;
+            const inlinePlan = evidence.planExit.inline;
             if (inlinePlan?.content || inlinePlan?.path) {
                 this.nativePlan = inlinePlan;
                 this.finishSuccess(inlinePlan.content ?? "");
                 return;
             }
-            this.readingPlan = true;
+            if (this.readingPlanGeneration === generation)
+                return;
+            this.readingPlanGeneration = generation;
+            const deadline = Date.now() + PLAN_READ_TIMEOUT_MS;
             try {
-                this.nativePlan = await readPlanWithRetry(this.registration, this.abort.signal);
-                if (this.disposed)
+                const plan = await readPlanWithRetry(this.registration, this.abort.signal, deadline);
+                await this.registration.waitForUsableConnection({
+                    signal: this.abort.signal, timeoutMs: Math.max(1, deadline - Date.now()),
+                });
+                if (this.disposed || !this.registration.outcomesAvailable || !this.ownsCurrentRequest(generation))
                     return;
-                this.finishSuccess(this.nativePlan.content ?? "");
+                this.nativePlan = plan;
+                this.finishSuccess(plan.content ?? "");
             }
             catch (err) {
-                this.finishError(err instanceof Error ? err : new Error(String(err)));
+                if (this.ownsCurrentRequest(generation))
+                    this.finishError(err instanceof Error ? err : new Error(String(err)));
             }
             return;
         }
-        await this.evaluate();
-    }
-    async evaluate() {
-        if (this.completed || this.disposed || this.readingPlan)
-            return;
         if (this.opts.completionMarkerFile) {
             return;
         }
-        const evidence = this.registration.evidence;
-        if (evidence.submitIndex >= this.startIndex && evidence.abortIndex >= this.startIndex) {
-            this.finishError(new Error("Copilot session aborted before completing the active turn"));
-            return;
-        }
-        const complete = evidence.submitIndex >= this.startIndex && evidence.settled;
+        const complete = owned && evidence.settled;
         if (this.completionGate) {
             this.completionGate.observeMarker();
             if (!this.completionGate.evaluate(complete))
@@ -1724,10 +2315,10 @@ export class CopilotLiveCompletionDetector {
         }
         else if (!complete)
             return;
-        this.finishSuccess(this.responseParts.join("\n"));
+        this.finishSuccess(evidence.responseParts.join("\n"));
     }
     checkMarker() {
-        if (this.completed || this.disposed || !this.opts.completionMarkerFile)
+        if (this.completed || this.disposed || !this.opts.completionMarkerFile || !this.registration.outcomesAvailable)
             return;
         let markerPresent = false;
         try {
@@ -1738,7 +2329,8 @@ export class CopilotLiveCompletionDetector {
         }
         if (!markerPresent)
             return;
-        this.finishSuccess(this.responseParts.join("\n"));
+        const evidence = this.registration.evidence;
+        this.finishSuccess(evidence.responseParts.slice(evidence.generation === this.startGeneration ? this.initialResponsePartCount : 0).join("\n"));
     }
     fireActivationIfNeeded() {
         if (this.activationFired)
@@ -1761,8 +2353,7 @@ export class CopilotLiveCompletionDetector {
         this.reject?.(error);
     }
 }
-async function readPlanWithRetry(registration, signal) {
-    const deadline = Date.now() + PLAN_READ_TIMEOUT_MS;
+async function readPlanWithRetry(registration, signal, deadline = Date.now() + PLAN_READ_TIMEOUT_MS) {
     let last;
     while (Date.now() < deadline) {
         throwIfAborted(signal);
@@ -1783,16 +2374,6 @@ function isSessionIdle(line, sessionId) {
 function isAbortEvent(line) {
     return line.type === "session.abort" || line.type === "abort";
 }
-function isExitPlanRequested(line) {
-    if (line.type === "exit_plan_mode.requested")
-        return true;
-    if (line.type !== "assistant.message")
-        return false;
-    const data = recordProp(line, "data");
-    const requests = data?.toolRequests;
-    return Array.isArray(requests)
-        && requests.some((request) => isRecord(request) && stringProp(request, "name") === "exit_plan_mode");
-}
 function nativePlanFromExitEvent(line) {
     if (line.type !== "exit_plan_mode.requested")
         return undefined;
@@ -1841,6 +2422,9 @@ function parseInbound(value) {
             workspacePath: stringProp(value, "workspacePath"),
             error: stringProp(value, "error"),
             eventIds: value.eventIds,
+            afterEventId: stringProp(value, "afterEventId"),
+            event: isRecord(value.event) ? value.event : undefined,
+            recoveryRejection: parseRecoveryRejection(value.recoveryRejection),
         };
     }
     if (value.kind === "event") {
@@ -1848,11 +2432,27 @@ function parseInbound(value) {
         if (!Number.isInteger(seq) || Number(seq) <= 0 || !isRecord(value.event)) {
             throw new Error("Copilot observer event message is malformed");
         }
+        if (value.origin !== "live" && value.origin !== "history" && value.origin !== "bridge") {
+            throw new Error("Copilot observer event is missing a valid origin");
+        }
+        if (value.transient !== undefined && typeof value.transient !== "boolean") {
+            throw new Error("Copilot observer event has invalid durability metadata");
+        }
+        if (value.lifecycleDurability !== undefined
+            && (value.lifecycleDurability !== "sdk-history" || value.origin !== "live"
+                || (value.event.type !== "session.start" && value.event.type !== "session.resume")
+                || !stringProp(value.event, "id") || value.event.ephemeral === true || value.transient === true)) {
+            throw new Error("Copilot observer event has invalid lifecycle durability proof");
+        }
         return {
             kind: "event",
             seq: Number(seq),
             event: value.event,
             sessionId: stringProp(value, "sessionId"),
+            origin: value.origin,
+            transient: value.transient,
+            lifecycleDurability: value.lifecycleDurability,
+            toolCallId: stringProp(value, "toolCallId"),
         };
     }
     if (value.kind === "rpc.response") {
@@ -1870,6 +2470,34 @@ function parseInbound(value) {
     }
     throw new Error("Copilot observer sent an unknown message kind");
 }
+function parseRecoveryRejection(value) {
+    if (value === undefined)
+        return undefined;
+    const invalid = () => new Error("Copilot observer recovery rejection metadata is malformed");
+    if (!isRecord(value))
+        throw invalid();
+    const { stage, boundary } = value;
+    if (stage !== "history-read" && stage !== "boundary-lookup" && stage !== "startup-verification"
+        && stage !== "admission" && stage !== "reconciliation")
+        throw invalid();
+    if (boundary !== "absent" && boundary !== "located" && boundary !== "missing"
+        && boundary !== "untrustworthy" && boundary !== "unknown")
+        throw invalid();
+    if (value.event === undefined)
+        return { stage, boundary };
+    if (!isRecord(value.event))
+        throw invalid();
+    const { type, source, ephemeral, historyMatch, parentReference, parentResolution } = value.event;
+    if (typeof type !== "string" || !/^[a-zA-Z0-9_.-]{1,96}$/.test(type)
+        || (source !== "live" && source !== "history" && source !== "bridge")
+        || typeof ephemeral !== "boolean"
+        || (historyMatch !== "matched" && historyMatch !== "absent" && historyMatch !== "unknown")
+        || (parentReference !== "omitted" && parentReference !== "null" && parentReference !== "supplied")
+        || (parentResolution !== "history" && parentResolution !== "callback" && parentResolution !== "unresolved"
+            && parentResolution !== "unknown" && parentResolution !== "none"))
+        throw invalid();
+    return { stage, boundary, event: { type, source, ephemeral, historyMatch, parentReference, parentResolution } };
+}
 function parsePlanReadResult(value) {
     if (!isRecord(value))
         return {};