poly-weaver 0.15.3 → 1.0.0

package/dist/providers/copilot/observation.js

@@ -0,0 +1,2072 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { COPILOT_PARENT_ENV_TO_CLEAR } from "./environment.js";
+import { existsSync } from "node:fs";
+import { chmod, cp, mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, normalize } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createServer } from "node:net";
+import { sendComposerText } from "../../terminal/paste-submit.js";
+import { abortableSleep, throwIfAborted } from "../../session/locator.js";
+import { SessionTurnReceipt, } from "../../offscreen/session-turn-receipt.js";
+import { isRecord } from "../trust-utils.js";
+import { recordProp, stringProp, rawStringProp } from "./record-properties.js";
+import { CopilotBackgroundWorkState, CopilotFinalBoundaryState, isCopilotTurnInitiatingUserLine as isLiveRootSubmit, } from "./completion.js";
+import { CopilotQACaptureError, extractCopilotClarifications, getCopilotSessionDir, } from "./session.js";
+import { CopilotComposerInspector } from "./composer.js";
+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";
+const OBSERVER_EXTENSION_TEMPLATE_NAME = "poly-weaver-observer";
+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 PLAN_READ_TIMEOUT_MS = 5_000;
+const PLAN_READ_RETRY_MS = 250;
+const OBSERVER_DIAGNOSTIC_EVENT_TAIL_LIMIT = 80;
+// Yield to timers/input and sibling launches, not just the microtask queue.
+export const COPILOT_OBSERVER_WORK_QUANTUM = 128;
+const OBSERVER_MAX_FRAME_CHARS = 16 * 1024 * 1024;
+const OBSERVER_MAX_PENDING_CHARS = 64 * 1024 * 1024;
+const OBSERVER_MAX_TENTATIVE_EVENTS = 131_072;
+export const COPILOT_OBSERVER_ENV = {
+    endpoint: "POLY_WEAVER_COPILOT_OBSERVER_ENDPOINT",
+    launchId: "POLY_WEAVER_COPILOT_OBSERVER_LAUNCH_ID",
+    sessionId: "POLY_WEAVER_COPILOT_OBSERVER_SESSION_ID",
+    credential: "POLY_WEAVER_COPILOT_OBSERVER_CREDENTIAL",
+    runSecret: "POLY_WEAVER_COPILOT_OBSERVER_RUN_SECRET",
+    sdkImport: "POLY_WEAVER_COPILOT_SDK_IMPORT",
+};
+export class CopilotObservationBroker {
+    registrations = new Map();
+    runId = randomUUID();
+    runSecret = token();
+    server;
+    endpointValue;
+    closed = false;
+    static async start() {
+        const broker = new CopilotObservationBroker();
+        await broker.listen();
+        return broker;
+    }
+    get endpoint() {
+        if (!this.endpointValue) {
+            throw new Error("Copilot observation broker has not started");
+        }
+        return this.endpointValue;
+    }
+    registerLaunch(sessionId) {
+        if (this.closed) {
+            throw new Error("Copilot observation broker is closed");
+        }
+        const launchId = randomUUID();
+        const registration = new CopilotLaunchRegistration({
+            launchId,
+            sessionId,
+            credential: token(),
+            runSecret: this.runSecret,
+            runId: this.runId,
+            broker: this,
+        });
+        this.registrations.set(launchId, registration);
+        return registration;
+    }
+    unregisterLaunch(registration) {
+        if (this.registrations.get(registration.launchId) === registration) {
+            this.registrations.delete(registration.launchId);
+        }
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const registration of this.registrations.values()) {
+            registration.dispose();
+        }
+        this.registrations.clear();
+        const server = this.server;
+        this.server = undefined;
+        if (!server)
+            return;
+        await new Promise((resolve, reject) => {
+            server.close((err) => (err ? reject(err) : resolve()));
+        }).catch(() => { });
+        if (this.endpointValue && process.platform !== "win32") {
+            await rm(this.endpointValue, { force: true }).catch(() => { });
+        }
+    }
+    async listen() {
+        const endpoint = await createEndpoint();
+        const server = createServer((socket) => this.accept(socket));
+        this.server = server;
+        this.endpointValue = endpoint;
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(endpoint, () => {
+                server.off("error", reject);
+                resolve();
+            });
+        });
+        if (process.platform !== "win32") {
+            await chmod(endpoint, 0o600).catch(() => { });
+        }
+    }
+    accept(socket) {
+        let authed;
+        let chunks = [];
+        let cursor = 0;
+        let offset = 0;
+        let pendingChars = 0;
+        let parts = [];
+        let frameChars = 0;
+        let scheduled;
+        let ended = false;
+        let stopped = false;
+        let closeCause;
+        const fail = (message) => {
+            stopped = true;
+            if (scheduled)
+                clearImmediate(scheduled);
+            chunks = [];
+            parts = [];
+            const error = new Error(message);
+            if (authed) {
+                authed.protocolFailure(socket, error);
+                socket.destroy(error);
+                return;
+            }
+            sendAuthResult(socket, { accepted: false, reason: message });
+            socket.end();
+        };
+        const drain = () => {
+            scheduled = undefined;
+            if (stopped)
+                return;
+            if (authed && !authed.ownsConnection(socket)) {
+                stopped = true;
+                chunks = [];
+                parts = [];
+                return;
+            }
+            // Let admitted replay catch up before accepting more live frames. The
+            // paused socket carries this pressure back to the extension's writer.
+            if (authed?.isConnectionDraining(socket)) {
+                scheduled = setImmediate(drain);
+                return;
+            }
+            let work = 0;
+            while (cursor < chunks.length && work++ < COPILOT_OBSERVER_WORK_QUANTUM) {
+                const chunk = chunks[cursor];
+                const newline = chunk.indexOf("\n", offset);
+                const end = newline < 0 ? chunk.length : newline;
+                const fragment = chunk.slice(offset, end);
+                frameChars += fragment.length;
+                if (frameChars > OBSERVER_MAX_FRAME_CHARS) {
+                    fail("Copilot observer frame exceeds the transport resource limit");
+                    return;
+                }
+                parts.push(fragment);
+                pendingChars -= end - offset + (newline < 0 ? 0 : 1);
+                offset = end + 1;
+                if (offset >= chunk.length) {
+                    cursor++;
+                    offset = 0;
+                }
+                if (newline < 0)
+                    continue;
+                const raw = parts.length === 1 ? parts[0] : parts.join("");
+                parts = [];
+                frameChars = 0;
+                if (raw.trim().length === 0)
+                    continue;
+                let message;
+                try {
+                    const parsed = JSON.parse(raw);
+                    message = parseInbound(parsed);
+                }
+                catch (err) {
+                    fail(err instanceof Error ? err.message : String(err));
+                    return;
+                }
+                if (!authed) {
+                    if (message.kind !== "auth") {
+                        fail("Copilot observer sent data before authentication");
+                        return;
+                    }
+                    const registration = this.registrations.get(message.launchId);
+                    if (!registration) {
+                        fail("Copilot observer authentication referenced an unknown launch");
+                        return;
+                    }
+                    let decision;
+                    try {
+                        decision = registration.authenticate(message, socket);
+                        sendAuthResult(socket, decision);
+                        if (!decision.accepted) {
+                            socket.end();
+                            return;
+                        }
+                    }
+                    catch (err) {
+                        fail(err instanceof Error ? err.message : String(err));
+                        return;
+                    }
+                    authed = registration;
+                    continue;
+                }
+                try {
+                    authed.accept(message, socket);
+                }
+                catch (err) {
+                    fail(err instanceof Error ? err.message : String(err));
+                    return;
+                }
+            }
+            if (cursor < chunks.length) {
+                scheduled = setImmediate(drain);
+            }
+            else {
+                chunks = [];
+                cursor = 0;
+                if (ended) {
+                    authed?.finishConnection(socket, closeCause);
+                    stopped = true;
+                }
+                else {
+                    socket.resume();
+                }
+            }
+        };
+        socket.setEncoding("utf8");
+        socket.on("data", (chunk) => {
+            if (stopped)
+                return;
+            chunks.push(chunk);
+            pendingChars += chunk.length;
+            if (pendingChars + frameChars > OBSERVER_MAX_PENDING_CHARS) {
+                fail("Copilot observer pending input exceeds the transport resource limit");
+                return;
+            }
+            socket.pause();
+            scheduled ??= setImmediate(drain);
+        });
+        socket.on("close", () => {
+            ended = true;
+            if (!stopped)
+                scheduled ??= setImmediate(drain);
+        });
+        socket.on("error", (err) => {
+            closeCause = err;
+        });
+    }
+}
+export class CopilotLaunchRegistration {
+    launchId;
+    sessionId;
+    credential;
+    runSecret;
+    runId;
+    broker;
+    activeConnection;
+    consumed = false;
+    connectionAttemptCount = 0;
+    rejectedDuplicateCount = 0;
+    lifecycleEventCount = 0;
+    epochCount = 0;
+    observerReadinessTimeoutMs = READY_TIMEOUT_MS;
+    workspacePath;
+    preferredExtensionDir;
+    readyIdentityValue;
+    recoveryCause;
+    recoveryDeadlineAt;
+    recoveryTimer;
+    failed;
+    disposed = false;
+    events = [];
+    seenEventIds = new Set();
+    seenEventReplayKeys = new Set();
+    excludeInheritedHistory = false;
+    inheritedEventIds;
+    eventHandlers = new Set();
+    errorHandlers = new Set();
+    readyWaiters = new Set();
+    pendingRpcs = new Map();
+    evidence = new CopilotLiveEvidence();
+    constructor(opts) {
+        this.launchId = opts.launchId;
+        this.sessionId = opts.sessionId;
+        this.credential = opts.credential;
+        this.runSecret = opts.runSecret;
+        this.runId = opts.runId;
+        this.broker = opts.broker;
+    }
+    get eventCount() {
+        return this.events.length;
+    }
+    ownsConnection(socket) {
+        return !this.disposed && !this.failed && this.activeConnection?.socket === socket;
+    }
+    isConnectionDraining(socket) {
+        return this.activeConnection?.socket === socket && this.activeConnection.drain !== undefined;
+    }
+    snapshotEvents(startIndex = 0) {
+        return this.events.slice(startIndex);
+    }
+    snapshotDiagnostics() {
+        const connection = this.activeConnection;
+        const currentReady = connection !== undefined && this.isConnectionReady(connection);
+        return {
+            provider: "copilot",
+            runId: this.runId,
+            launchId: this.launchId,
+            sessionId: this.sessionId,
+            connected: connection !== undefined,
+            accepted: this.consumed,
+            ready: currentReady,
+            subscriptionReady: connection?.subscriptionReady ?? false,
+            joinedSessionReady: connection?.joinedSessionReady ?? false,
+            lifecycleReady: connection?.lifecycleReady ?? false,
+            currentEpoch: connection?.epoch ?? 0,
+            epochCount: this.epochCount,
+            replacementCount: Math.max(0, this.epochCount - 1),
+            recovering: this.recoveryCause !== undefined,
+            connectionAttemptCount: this.connectionAttemptCount,
+            rejectedDuplicateCount: this.rejectedDuplicateCount,
+            lifecycleEventCount: this.lifecycleEventCount,
+            eventCount: this.events.length,
+            lastEventSeq: connection ? connection.nextSeq - 1 : 0,
+            eventTail: diagnosticEventTail(this.events),
+            disposed: this.disposed,
+            ...(this.workspacePath && { workspacePath: this.workspacePath }),
+            ...(this.recoveryDeadlineAt !== undefined && { recoveryDeadlineAt: this.recoveryDeadlineAt }),
+            ...(this.recoveryCause && { retainedDisconnectReason: this.recoveryCause.message }),
+            ...(this.failed && { failureReason: this.failed.message }),
+        };
+    }
+    authenticate(message, socket) {
+        this.connectionAttemptCount++;
+        if (this.disposed) {
+            return {
+                accepted: false,
+                reason: "Copilot observer attempted to use a disposed launch registration",
+            };
+        }
+        if (this.failed) {
+            return {
+                accepted: false,
+                reason: "Copilot observer attempted to use a failed launch registration",
+            };
+        }
+        if (message.sessionId !== this.sessionId ||
+            message.credential !== this.credential ||
+            message.runSecret !== this.runSecret) {
+            throw new Error("Copilot observer authentication failed");
+        }
+        const incomingIsPreferred = this.isPreferredExtensionPath(message.extensionPath);
+        if (this.activeConnection && this.activeConnection.socket !== socket) {
+            this.rejectedDuplicateCount++;
+            return {
+                accepted: false,
+                reason: "Copilot observer duplicate activation rejected",
+            };
+        }
+        if (!incomingIsPreferred) {
+            this.rejectedDuplicateCount++;
+            return {
+                accepted: false,
+                reason: "Copilot observer non-authoritative activation rejected",
+            };
+        }
+        this.consumed = true;
+        this.activeConnection = {
+            socket,
+            epoch: ++this.epochCount,
+            nextSeq: 1,
+            subscriptionReady: false,
+            joinedSessionReady: false,
+            lifecycleReady: false,
+            bufferedEvents: [],
+            bufferedCursor: 0,
+            bufferedChars: 0,
+            extensionPath: message.extensionPath,
+        };
+        return {
+            accepted: true,
+            replayHistory: this.events.length > 0,
+            ...(this.excludeInheritedHistory && !this.inheritedEventIds && { captureHistoryBaseline: true }),
+        };
+    }
+    accept(message, socket) {
+        if (this.disposed)
+            return;
+        const connection = this.activeConnection;
+        if (!connection || socket !== connection.socket)
+            return;
+        if (message.kind === "auth") {
+            this.fail(new Error("Copilot observer attempted to authenticate twice"));
+            return;
+        }
+        if (message.kind === "event") {
+            this.acceptEvent(message, connection);
+            return;
+        }
+        if (message.kind === "control") {
+            this.acceptControl(message, connection);
+            return;
+        }
+        this.acceptRpcResponse(message, connection);
+    }
+    waitForReady(opts = {}) {
+        const timeoutMs = opts.timeoutMs ?? this.observerReadinessTimeoutMs;
+        if (!this.readyIdentityValue) {
+            this.observerReadinessTimeoutMs = timeoutMs;
+        }
+        return this.waitForCurrentReady({
+            ...opts,
+            timeoutMs,
+            timeoutMessage: `Timed out waiting for Copilot observer readiness for session ${this.sessionId}`,
+        });
+    }
+    waitForUsableConnection(opts = {}) {
+        return this.waitForCurrentReady({
+            ...opts,
+            timeoutMessage: `Timed out waiting for usable Copilot observer connection for session ${this.sessionId}`,
+        });
+    }
+    async waitForCurrentReady(opts) {
+        throwIfAborted(opts.signal);
+        if (this.failed)
+            return Promise.reject(this.failed);
+        if (this.disposed)
+            return Promise.reject(new Error("Copilot observer disposed"));
+        const ready = this.currentReadyIdentity();
+        if (ready)
+            return Promise.resolve(ready);
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve,
+                reject,
+                signal: opts.signal,
+            };
+            if (opts.timeoutMs !== undefined) {
+                waiter.timer = setTimeout(() => {
+                    this.readyWaiters.delete(waiter);
+                    cleanupReadyWaiter(waiter);
+                    reject(new Error(opts.timeoutMessage));
+                }, opts.timeoutMs);
+            }
+            if (opts.signal) {
+                waiter.onAbort = () => {
+                    this.readyWaiters.delete(waiter);
+                    if (waiter.timer)
+                        clearTimeout(waiter.timer);
+                    cleanupReadyWaiter(waiter);
+                    try {
+                        throwIfAborted(opts.signal);
+                    }
+                    catch (err) {
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    }
+                };
+                opts.signal.addEventListener("abort", waiter.onAbort, { once: true });
+            }
+            this.readyWaiters.add(waiter);
+        });
+    }
+    onEvent(handler) {
+        this.eventHandlers.add(handler);
+        return () => {
+            this.eventHandlers.delete(handler);
+        };
+    }
+    onError(handler) {
+        this.errorHandlers.add(handler);
+        if (this.failed)
+            handler(this.failed);
+        return () => {
+            this.errorHandlers.delete(handler);
+        };
+    }
+    requestPlanRead(timeoutMs = PLAN_READ_TIMEOUT_MS) {
+        return this.requestRpc({
+            kind: "rpc.request",
+            requestId: randomUUID(),
+            method: "plan.read",
+        }, timeoutMs).then(parsePlanReadResult);
+    }
+    requestRpc(request, timeoutMs) {
+        if (this.failed)
+            return Promise.reject(this.failed);
+        if (this.disposed)
+            return Promise.reject(new Error("Copilot observer disposed"));
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRpcs.delete(request.requestId);
+                reject(new Error(`Timed out waiting for Copilot observer RPC ${request.method}`));
+            }, timeoutMs);
+            this.pendingRpcs.set(request.requestId, {
+                request,
+                resolve,
+                reject,
+                timer,
+            });
+            this.sendPendingRpcIfUsable(request.requestId);
+        });
+    }
+    disconnect(socket, cause) {
+        if (this.disposed || this.failed)
+            return;
+        const connection = this.activeConnection;
+        if (!connection || socket !== connection.socket)
+            return;
+        const launchWasReady = this.readyIdentityValue !== undefined;
+        if (connection.drain)
+            clearImmediate(connection.drain);
+        this.activeConnection = undefined;
+        for (const pending of this.pendingRpcs.values()) {
+            if (pending.sentEpoch === connection.epoch)
+                pending.sentEpoch = undefined;
+        }
+        if (!launchWasReady) {
+            this.workspacePath = undefined;
+            return;
+        }
+        this.startRecovery(this.disconnectCause(connection, cause));
+    }
+    /** Drain admitted evidence before reporting transport loss; tentative epochs are discarded. */
+    finishConnection(socket, cause) {
+        const connection = this.activeConnection;
+        if (!connection || connection.socket !== socket)
+            return;
+        if (connection.drain) {
+            connection.closed = { cause };
+            return;
+        }
+        this.disconnect(socket, cause);
+    }
+    protocolFailure(socket, error) {
+        const connection = this.activeConnection;
+        if (!connection || socket !== connection.socket)
+            return;
+        this.fail(error);
+    }
+    fail(error) {
+        if (this.failed)
+            return;
+        this.failed = error;
+        this.clearRecovery();
+        const connection = this.activeConnection;
+        this.activeConnection = undefined;
+        if (connection?.drain)
+            clearImmediate(connection.drain);
+        connection?.socket.destroy();
+        for (const waiter of this.readyWaiters) {
+            if (waiter.timer)
+                clearTimeout(waiter.timer);
+            cleanupReadyWaiter(waiter);
+            waiter.reject(error);
+        }
+        this.readyWaiters.clear();
+        for (const pending of this.pendingRpcs.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pendingRpcs.clear();
+        for (const handler of this.errorHandlers)
+            handler(error);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.broker.unregisterLaunch(this);
+        const disposedError = new Error("Copilot observer disposed");
+        this.clearRecovery();
+        for (const waiter of this.readyWaiters) {
+            if (waiter.timer)
+                clearTimeout(waiter.timer);
+            cleanupReadyWaiter(waiter);
+            waiter.reject(disposedError);
+        }
+        this.readyWaiters.clear();
+        for (const pending of this.pendingRpcs.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(disposedError);
+        }
+        this.pendingRpcs.clear();
+        this.eventHandlers.clear();
+        this.errorHandlers.clear();
+        if (this.activeConnection?.drain)
+            clearImmediate(this.activeConnection.drain);
+        this.activeConnection?.socket.destroy();
+        this.activeConnection = undefined;
+    }
+    setPreferredExtensionDir(extensionDir) {
+        this.preferredExtensionDir = extensionDir;
+    }
+    requireInheritedHistoryBoundary() {
+        this.excludeInheritedHistory = true;
+    }
+    acceptEvent(message, connection) {
+        if (message.seq !== connection.nextSeq) {
+            this.fail(new Error(`Copilot observer sequence violation for launch ${this.launchId}: expected ${connection.nextSeq}, got ${message.seq}`));
+            return;
+        }
+        connection.nextSeq++;
+        const eventId = stringProp(message.event, "id");
+        if (eventId && this.inheritedEventIds?.has(eventId))
+            return;
+        const historyPayloadError = validateLiveHistoryEventPayload(message.event);
+        if (historyPayloadError) {
+            this.fail(new Error(historyPayloadError));
+            return;
+        }
+        connection.bufferedEvents.push(message.event);
+        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))
+            return;
+        this.resolveReadyIfPossible(connection);
+    }
+    acceptControl(message, connection) {
+        if (message.type === "inquiry.history_baseline") {
+            if (!this.excludeInheritedHistory || this.inheritedEventIds || connection.inheritedEventIds
+                || !connection.joinedSessionReady || connection.subscriptionReady
+                || !Array.isArray(message.eventIds)
+                || !message.eventIds.every((id) => typeof id === "string" && id.length > 0)) {
+                this.fail(new Error("Copilot observer reported an invalid inherited-history boundary"));
+                return;
+            }
+            connection.inheritedEventIds = new Set(message.eventIds);
+            this.resolveReadyIfPossible(connection);
+            return;
+        }
+        if (message.type === "subscription.ready") {
+            connection.subscriptionReady = true;
+            this.resolveReadyIfPossible(connection);
+            return;
+        }
+        if (message.type === "session.joined") {
+            if (message.sessionId && message.sessionId !== this.sessionId) {
+                this.fail(new Error(`Copilot observer joined unexpected session ${message.sessionId}; expected ${this.sessionId}`));
+                return;
+            }
+            if (!message.sessionId) {
+                this.fail(new Error("Copilot observer did not report a joined session id"));
+                return;
+            }
+            this.workspacePath = message.workspacePath;
+            connection.workspacePath = message.workspacePath;
+            connection.joinedSessionReady = true;
+            this.resolveReadyIfPossible(connection);
+            return;
+        }
+        if (message.type === "sdk.error" || message.type === "observer.error") {
+            this.fail(new Error(message.error || "Copilot observer reported an error"));
+        }
+    }
+    acceptRpcResponse(message, connection) {
+        const pending = this.pendingRpcs.get(message.requestId);
+        if (!pending) {
+            this.fail(new Error(`Copilot observer returned unknown RPC request ${message.requestId}`));
+            return;
+        }
+        if (pending.sentEpoch !== connection.epoch)
+            return;
+        this.pendingRpcs.delete(message.requestId);
+        clearTimeout(pending.timer);
+        if (message.ok) {
+            pending.resolve(message.result);
+        }
+        else {
+            pending.reject(new Error(message.error || "Copilot observer RPC failed"));
+        }
+    }
+    updateLifecycle(event, connection) {
+        if (event.type !== "session.start" && event.type !== "session.resume") {
+            return true;
+        }
+        const rawSessionId = sessionIdFromEvent(event);
+        if (rawSessionId !== undefined && rawSessionId !== this.sessionId) {
+            this.fail(new Error(`Copilot observer lifecycle session mismatch: expected ${this.sessionId}, got ${rawSessionId}`));
+            return false;
+        }
+        connection.lifecycleReady = true;
+        return !this.failed;
+    }
+    resolveReadyIfPossible(connection) {
+        if (connection !== this.activeConnection || !this.isConnectionAdmitted(connection))
+            return;
+        if (connection.bufferedCursor < connection.bufferedEvents.length) {
+            connection.drain ??= setImmediate(() => this.flushConnectionEventsIfReady(connection));
+            return;
+        }
+        const ready = this.readyIdentityValue ?? this.createReadyIdentity();
+        if (this.excludeInheritedHistory && !this.inheritedEventIds) {
+            this.inheritedEventIds = connection.inheritedEventIds;
+        }
+        this.readyIdentityValue = ready;
+        this.clearRecovery();
+        if (connection.closed) {
+            this.disconnect(connection.socket, connection.closed.cause);
+            return;
+        }
+        for (const waiter of this.readyWaiters) {
+            if (waiter.timer)
+                clearTimeout(waiter.timer);
+            cleanupReadyWaiter(waiter);
+            waiter.resolve(ready);
+        }
+        this.readyWaiters.clear();
+        this.flushPendingRpcs();
+    }
+    currentReadyIdentity() {
+        const connection = this.activeConnection;
+        if (!connection || !this.isConnectionReady(connection)) {
+            return undefined;
+        }
+        return this.readyIdentityValue ?? this.createReadyIdentity();
+    }
+    createReadyIdentity() {
+        return {
+            sessionId: this.sessionId,
+            sessionFilePath: join(getCopilotSessionDir(), this.sessionId, "events.jsonl"),
+            lineOffset: 0,
+        };
+    }
+    isConnectionReady(connection) {
+        return this.isConnectionAdmitted(connection)
+            && connection.bufferedCursor === connection.bufferedEvents.length && !connection.drain;
+    }
+    isConnectionAdmitted(connection) {
+        return connection.subscriptionReady && connection.joinedSessionReady && connection.lifecycleReady
+            && (!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) {
+            connection.bufferedEvents = [];
+            connection.bufferedCursor = 0;
+            connection.bufferedChars = 0;
+        }
+        this.resolveReadyIfPossible(connection);
+    }
+    commitEvent(event) {
+        if (event.type === "session.start" || event.type === "session.resume") {
+            this.lifecycleEventCount++;
+        }
+        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()) {
+            this.sendPendingRpcIfUsable(requestId);
+        }
+    }
+    sendPendingRpcIfUsable(requestId) {
+        const pending = this.pendingRpcs.get(requestId);
+        const connection = this.activeConnection;
+        if (!pending || !connection || !this.isConnectionReady(connection))
+            return;
+        if (pending.sentEpoch === connection.epoch)
+            return;
+        try {
+            connection.socket.write(`${JSON.stringify(pending.request)}\n`);
+            pending.sentEpoch = connection.epoch;
+        }
+        catch (err) {
+            pending.sentEpoch = undefined;
+            this.disconnect(connection.socket, err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    startRecovery(cause) {
+        if (this.recoveryCause || this.failed || this.disposed)
+            return;
+        this.recoveryCause = cause;
+        this.recoveryDeadlineAt = Date.now() + this.observerReadinessTimeoutMs;
+        this.recoveryTimer = setTimeout(() => {
+            this.recoveryTimer = undefined;
+            this.fail(this.recoveryCause ?? cause);
+        }, Math.max(0, this.recoveryDeadlineAt - Date.now()));
+    }
+    clearRecovery() {
+        if (this.recoveryTimer)
+            clearTimeout(this.recoveryTimer);
+        this.recoveryTimer = undefined;
+        this.recoveryCause = undefined;
+        this.recoveryDeadlineAt = undefined;
+    }
+    disconnectCause(connection, cause) {
+        if (cause)
+            return cause;
+        return new Error(connection.extensionPath
+            ? `Copilot observer disconnected before process completion (${connection.extensionPath})`
+            : "Copilot observer disconnected before process completion");
+    }
+    isPreferredExtensionPath(extensionPath) {
+        if (!this.preferredExtensionDir || !extensionPath)
+            return true;
+        return samePath(dirname(extensionPath), this.preferredExtensionDir);
+    }
+}
+export function copilotObserverPluginIdentityForLaunchId(launchId) {
+    const compactId = launchId.toLowerCase().replace(/-/g, "");
+    const identity = `${OBSERVER_PLUGIN_IDENTITY_PREFIX}-${compactId}`;
+    assertValidCopilotObserverPluginIdentity(identity);
+    return identity;
+}
+export class CopilotProcessObserver {
+    broker;
+    registration;
+    tempRoot;
+    pluginDir;
+    pluginIdentity;
+    extensionDir;
+    sessionExtensionDir;
+    sdkPath;
+    ownsBroker;
+    ownsTempRoot;
+    onDispose;
+    deferInitialPrompt = true;
+    args;
+    env;
+    disposed = false;
+    composer = new CopilotComposerInspector();
+    constructor(broker, registration, tempRoot, pluginDir, pluginIdentity, extensionDir, sessionExtensionDir, sdkPath, sdkEntryPath, ownsBroker, ownsTempRoot, onDispose) {
+        this.broker = broker;
+        this.registration = registration;
+        this.tempRoot = tempRoot;
+        this.pluginDir = pluginDir;
+        this.pluginIdentity = pluginIdentity;
+        this.extensionDir = extensionDir;
+        this.sessionExtensionDir = sessionExtensionDir;
+        this.sdkPath = sdkPath;
+        this.ownsBroker = ownsBroker;
+        this.ownsTempRoot = ownsTempRoot;
+        this.onDispose = onDispose;
+        this.args = [
+            "--plugin-dir",
+            pluginDir,
+            "--extension-sdk-path",
+            sdkPath,
+            "--experimental",
+        ];
+        this.env = {
+            ...Object.fromEntries(COPILOT_PARENT_ENV_TO_CLEAR.map((key) => [key, ""])),
+            [COPILOT_OBSERVER_ENV.endpoint]: broker.endpoint,
+            [COPILOT_OBSERVER_ENV.launchId]: registration.launchId,
+            [COPILOT_OBSERVER_ENV.sessionId]: registration.sessionId,
+            [COPILOT_OBSERVER_ENV.credential]: registration.credential,
+            [COPILOT_OBSERVER_ENV.runSecret]: registration.runSecret,
+            [COPILOT_OBSERVER_ENV.sdkImport]: pathToFileURL(sdkEntryPath).href,
+        };
+    }
+    static async create(opts) {
+        const sessionId = requiredCopilotObserverSessionId(opts);
+        const broker = await CopilotObservationBroker.start();
+        try {
+            const sdkAssets = await resolveCopilotObserverSdkAssets();
+            return await CopilotProcessObserver.createWithResources(broker, sdkAssets, sessionId, true, opts.excludeInheritedHistory);
+        }
+        catch (err) {
+            await broker.close();
+            throw err;
+        }
+    }
+    static async createWithSharedBroker(broker, sdkAssets, opts, onDispose) {
+        const sessionId = requiredCopilotObserverSessionId(opts);
+        return CopilotProcessObserver.createWithResources(broker, sdkAssets, sessionId, false, opts.excludeInheritedHistory, onDispose);
+    }
+    static async createWithResources(broker, sdkAssets, sessionId, ownsBroker, excludeInheritedHistory = false, onDispose) {
+        let pluginAssets;
+        let registration;
+        try {
+            registration = broker.registerLaunch(sessionId);
+            if (excludeInheritedHistory)
+                registration.requireInheritedHistoryBoundary();
+            const pluginIdentity = copilotObserverPluginIdentityForLaunchId(registration.launchId);
+            pluginAssets = await prepareCopilotObserverPluginAssets(pluginIdentity, registration.launchId, sessionId);
+            registration.setPreferredExtensionDir(pluginAssets.sessionExtensionDir);
+            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);
+            }
+            throw err;
+        }
+    }
+    get launchId() {
+        return this.registration.launchId;
+    }
+    get sessionId() {
+        return this.registration.sessionId;
+    }
+    waitForReady(_handle, opts) {
+        return this.registration.waitForReady(opts);
+    }
+    async submitPrompt(target, prompt, opts = {}) {
+        await this.registration.waitForUsableConnection({ signal: opts.signal });
+        await sendComposerText(target, prompt, this.composer, {
+            signal: opts.signal,
+            escapeBeforePaste: true,
+            beforeSubmit: async () => {
+                await this.registration.waitForUsableConnection({ signal: opts.signal });
+            },
+        });
+    }
+    createDetector(opts) {
+        return new CopilotLiveCompletionDetector(this.registration, opts);
+    }
+    createTurnMonitor(opts) {
+        return new CopilotLiveTurnMonitor(this.registration, opts);
+    }
+    onError(handler) {
+        return this.registration.onError(handler);
+    }
+    snapshotDiagnostics() {
+        return {
+            ...this.registration.snapshotDiagnostics(),
+            observerPluginName: this.pluginIdentity,
+            observerPluginDir: this.pluginDir,
+            observerExtensionDir: this.extensionDir,
+            observerSessionExtensionDir: this.sessionExtensionDir,
+            sdkPath: this.sdkPath,
+        };
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        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(() => { }),
+        ]);
+    }
+}
+export class CopilotObserverRun {
+    provider = "copilot";
+    disposed = false;
+    observers = new Set();
+    sharedResourcesValue;
+    sharedResourcesPromise;
+    constructor() { }
+    static async create() {
+        return new CopilotObserverRun();
+    }
+    async prepareLaunchObserver(opts) {
+        if (this.disposed) {
+            throw disposedCopilotObserverRunError();
+        }
+        requiredCopilotObserverSessionId(opts);
+        const resources = await this.sharedResources();
+        const observer = await CopilotProcessObserver.createWithSharedBroker(resources.broker, resources.sdkAssets, opts, (observer) => this.observers.delete(observer));
+        if (this.disposed) {
+            await observer.dispose();
+            throw disposedCopilotObserverRunError();
+        }
+        this.observers.add(observer);
+        return observer;
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        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();
+    }
+    sharedResources() {
+        if (this.disposed) {
+            return Promise.reject(disposedCopilotObserverRunError());
+        }
+        if (this.sharedResourcesValue) {
+            return Promise.resolve(this.sharedResourcesValue);
+        }
+        this.sharedResourcesPromise ??= this.initializeSharedResources().catch((err) => {
+            this.sharedResourcesPromise = undefined;
+            throw err;
+        });
+        return this.sharedResourcesPromise.then(async (resources) => {
+            if (!this.disposed)
+                return resources;
+            if (this.sharedResourcesValue === resources) {
+                this.sharedResourcesValue = undefined;
+            }
+            await resources.broker.close();
+            throw disposedCopilotObserverRunError();
+        });
+    }
+    async initializeSharedResources() {
+        const broker = await CopilotObservationBroker.start();
+        try {
+            const sdkAssets = await resolveCopilotObserverSdkAssets();
+            if (this.disposed) {
+                throw disposedCopilotObserverRunError();
+            }
+            const resources = { broker, sdkAssets };
+            this.sharedResourcesValue = resources;
+            return resources;
+        }
+        catch (err) {
+            await broker.close();
+            throw err;
+        }
+    }
+}
+export function createCopilotObserverRun() {
+    return CopilotObserverRun.create();
+}
+async function resolveCopilotObserverSdkAssets() {
+    const sdkRequireEntry = createRequire(import.meta.url).resolve("@github/copilot-sdk/extension");
+    const sdkPath = sdkDistDir(sdkRequireEntry);
+    return {
+        sdkPath,
+        sdkEntryPath: join(sdkPath, "extension.js"),
+    };
+}
+async function prepareCopilotObserverPluginAssets(pluginIdentity, launchId, sessionId) {
+    assertValidCopilotObserverPluginIdentity(pluginIdentity);
+    assertSafeCopilotObserverPathSegment(sessionId, "session id");
+    const tempRoot = await mkdtemp(join(tmpdir(), "poly-weaver-copilot-observer-"));
+    const pluginDir = join(tempRoot, pluginIdentity);
+    const sessionExtensionDir = copilotObserverSessionExtensionDir(sessionId, pluginIdentity);
+    try {
+        const extensionDir = await materializeCopilotObserverPlugin(pluginDir, pluginIdentity, launchId);
+        await materializeCopilotObserverSessionExtensionDir(extensionDir, sessionExtensionDir);
+        return {
+            tempRoot,
+            pluginDir,
+            pluginIdentity,
+            extensionDir,
+            sessionExtensionDir,
+        };
+    }
+    catch (err) {
+        await Promise.allSettled([
+            rm(tempRoot, { recursive: true, force: true }),
+            rm(sessionExtensionDir, { recursive: true, force: true }),
+        ]);
+        throw err;
+    }
+}
+async function materializeCopilotObserverPlugin(pluginDir, pluginIdentity, launchId) {
+    assertValidCopilotObserverPluginIdentity(pluginIdentity);
+    await cp(OBSERVER_PLUGIN_ASSET_DIR, pluginDir, { recursive: true });
+    await rewriteCopilotObserverPluginManifest(pluginDir, pluginIdentity);
+    return await materializeCopilotObserverExtensionDir(pluginDir, pluginIdentity, launchId);
+}
+async function rewriteCopilotObserverPluginManifest(pluginDir, pluginIdentity) {
+    const manifestPath = join(pluginDir, "plugin.json");
+    const raw = await readFile(manifestPath, "utf-8");
+    const manifest = JSON.parse(raw);
+    if (manifest.name !== OBSERVER_PLUGIN_TEMPLATE_NAME) {
+        throw new Error("Copilot observer plugin template has an unexpected name");
+    }
+    if (typeof manifest.description !== "string" || manifest.description.length === 0) {
+        throw new Error("Copilot observer plugin template is missing description");
+    }
+    if (typeof manifest.version !== "string" || manifest.version.length === 0) {
+        throw new Error("Copilot observer plugin template is missing version");
+    }
+    if (manifest.extensions !== COPILOT_EXTENSIONS_CONTRACT) {
+        throw new Error("Copilot observer plugin template has an unexpected extensions contract");
+    }
+    await writeFile(manifestPath, `${JSON.stringify({
+        name: pluginIdentity,
+        description: manifest.description,
+        version: manifest.version,
+        extensions: manifest.extensions,
+    }, null, 2)}\n`, "utf-8");
+}
+async function materializeCopilotObserverExtensionDir(pluginDir, pluginIdentity, launchId) {
+    const extensionsRoot = join(pluginDir, "com.github.copilot", "extensions");
+    const sourceDir = join(extensionsRoot, OBSERVER_EXTENSION_TEMPLATE_NAME);
+    const targetDir = join(extensionsRoot, pluginIdentity);
+    if (sourceDir !== targetDir) {
+        await rename(sourceDir, targetDir);
+    }
+    const entrypoint = join(targetDir, "extension.mjs");
+    const source = await readFile(entrypoint, "utf-8");
+    await writeFile(entrypoint, `const polyWeaverExpectedLaunchId = ${JSON.stringify(launchId)};\n` +
+        `if (process.env.POLY_WEAVER_COPILOT_OBSERVER_LAUNCH_ID !== polyWeaverExpectedLaunchId) process.exit(0);\n` +
+        source, "utf-8");
+    return targetDir;
+}
+async function materializeCopilotObserverSessionExtensionDir(sourceDir, targetDir) {
+    await rm(targetDir, { recursive: true, force: true }).catch(() => { });
+    await mkdir(dirname(targetDir), { recursive: true });
+    await cp(sourceDir, targetDir, { recursive: true });
+}
+function copilotObserverSessionExtensionDir(sessionId, pluginIdentity) {
+    assertSafeCopilotObserverPathSegment(sessionId, "session id");
+    assertValidCopilotObserverPluginIdentity(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(() => { }),
+    ]);
+}
+function assertValidCopilotObserverPluginIdentity(identity) {
+    if (identity.length > COPILOT_PLUGIN_NAME_MAX_LENGTH
+        || !COPILOT_PLUGIN_NAME_PATTERN.test(identity)) {
+        throw new Error(`Invalid Copilot observer plugin identity ${JSON.stringify(identity)}`);
+    }
+}
+function assertSafeCopilotObserverPathSegment(value, label) {
+    if (value.length === 0
+        || value === "."
+        || value === ".."
+        || value.includes("/")
+        || value.includes("\\")
+        || value.includes(":")) {
+        throw new Error(`Invalid Copilot observer ${label} ${JSON.stringify(value)}`);
+    }
+}
+function samePath(left, right) {
+    const normalizedLeft = normalize(left);
+    const normalizedRight = normalize(right);
+    return process.platform === "win32"
+        ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+        : normalizedLeft === normalizedRight;
+}
+function sendAuthResult(socket, decision) {
+    const message = decision.accepted
+        ? {
+            kind: "auth.result",
+            accepted: true,
+            ...(decision.replayHistory && { replayHistory: true }),
+            ...(decision.captureHistoryBaseline && { captureHistoryBaseline: true }),
+        }
+        : { kind: "auth.result", accepted: false, reason: decision.reason };
+    socket.write(`${JSON.stringify(message)}\n`);
+}
+function requiredCopilotObserverSessionId(opts) {
+    const sessionId = opts.resumeSessionId ?? opts.sessionId;
+    if (!sessionId) {
+        throw new Error("Copilot observation requires a pre-assigned or resume session id");
+    }
+    return sessionId;
+}
+function disposedCopilotObserverRunError() {
+    return new Error("Copilot observer run has been disposed");
+}
+/** Launch-local authority. Snapshots/materialized output are explicit operations. */
+class CopilotLiveEvidence {
+    rewriteGeneration = 0;
+    submitIdentities = [];
+    removedSubmitIdentities = [];
+    submitIndex = -1;
+    abortIndex = -1;
+    assistantIndex = -1;
+    idleIndex = -1;
+    background = new CopilotBackgroundWorkState();
+    boundary = new CopilotFinalBoundaryState();
+    boundarySettled = false;
+    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) {
+        if (isLiveHistoryRewriteEvent(event)) {
+            this.rewriteGeneration++;
+            this.removedSubmitIdentities = this.submitIdentities;
+            this.submitIdentities = [];
+            this.resetTurn();
+            return;
+        }
+        if (isLiveRootSubmit(event)) {
+            this.resetTurn();
+            this.submitIndex = index;
+            this.submitIdentities.push(liveSubmitIdentity(event, index, this.rewriteGeneration));
+        }
+        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)) {
+            // Later background completion cannot validate an earlier stop.
+            this.boundarySettled = this.background.size === 0;
+        }
+    }
+    snapshot(scope) {
+        const submitIdentities = [...this.submitIdentities];
+        return {
+            value: {
+                kind: "copilot-live-observer-v2",
+                launchId: scope.launchId,
+                sessionId: scope.sessionId,
+                rewriteGeneration: this.rewriteGeneration,
+                submitIdentities,
+                lineCount: scope.eventCount,
+            },
+            submitCount: submitIdentities.length,
+            submitIdentities,
+            lineCount: scope.eventCount,
+        };
+    }
+    resetTurn() {
+        this.submitIndex = -1;
+        this.abortIndex = -1;
+        this.assistantIndex = -1;
+        this.idleIndex = -1;
+        this.background = new CopilotBackgroundWorkState();
+        this.boundary = new CopilotFinalBoundaryState();
+        this.boundarySettled = false;
+    }
+}
+class CopilotLiveTurnMonitor {
+    registration;
+    opts;
+    unsubscribeEvent;
+    unsubscribeError;
+    busy = false;
+    stopped = false;
+    coveredSubmitCount = 0;
+    expectedSubmitCount = 0;
+    observedSubmitCount = 0;
+    pendingAttempts = [];
+    entries = new Map();
+    attached = new WeakSet();
+    highestOrdinal = 0;
+    pendingAttemptWaiters = new Set();
+    attemptTimeoutMs;
+    historySnapshot;
+    historyRevision;
+    abort = new AbortController();
+    constructor(registration, opts = {}) {
+        this.registration = registration;
+        this.opts = opts;
+        this.attemptTimeoutMs = opts.attemptTimeoutMs ?? 5_000;
+        this.historySnapshot = opts.initialHistorySnapshot;
+        this.refreshCounts();
+        this.unsubscribeEvent = registration.onEvent(() => this.onEvent());
+        this.unsubscribeError = registration.onError((error) => {
+            if (this.stopped)
+                return;
+            this.busy = true;
+            this.opts.onReadFailure?.(error);
+            this.opts.onChange?.(false);
+        });
+    }
+    get isIdle() {
+        return !this.busy;
+    }
+    get lineBaseline() {
+        return this.coveredSubmitCount;
+    }
+    get currentSubmitFloor() {
+        return this.coveredSubmitCount;
+    }
+    get supportsHistoryRegression() {
+        return true;
+    }
+    startHistoryPolling() {
+        this.reconcileLiveHistory();
+    }
+    reserveTurn(boundary = {}) {
+        const receipt = new SessionTurnReceipt({
+            ...boundary,
+            anchorSubmitCount: boundary.anchorSubmitCount ?? this.observedSubmitCount,
+        });
+        this.attachTurn(receipt);
+        return receipt;
+    }
+    async reserveTurnFromSession() {
+        await this.registration.waitForUsableConnection({ signal: this.abort.signal });
+        this.refreshCounts();
+        this.reconcileLiveHistory();
+        return this.reserveTurn();
+    }
+    attachTurns(receipts) {
+        for (const receipt of [...receipts].sort((a, b) => a.sequence - b.sequence)) {
+            this.attachTurn(receipt);
+        }
+    }
+    attachTurn(receipt) {
+        if (this.stopped || this.attached.has(receipt) || receipt.settlement)
+            return;
+        this.attached.add(receipt);
+        const entry = { receipt };
+        this.entries.set(receipt.id, entry);
+        entry.unsubscribe = receipt.onChange(() => {
+            if (receipt.settlement === "released" && entry.ordinal === undefined) {
+                this.removeEntry(entry);
+                this.evaluateSettlement();
+            }
+        });
+        if (receipt.inputWritten && !receipt.rawAttempt)
+            this.confirmTurn(entry);
+    }
+    beginTurn(receipt) {
+        if (!receipt) {
+            const adopted = [...this.entries.values()].reverse().find((entry) => entry.receipt.rawAttempt
+                && entry.ordinal !== undefined
+                && entry.ordinal > this.coveredSubmitCount);
+            if (adopted)
+                return adopted.receipt;
+            receipt = this.reserveTurn();
+        }
+        if (this.stopped)
+            return receipt;
+        this.attachTurn(receipt);
+        receipt.confirm();
+        const entry = this.entries.get(receipt.id);
+        if (entry)
+            this.confirmTurn(entry);
+        return receipt;
+    }
+    confirmTurn(entry) {
+        if (entry.ordinal !== undefined || entry.receipt.settlement)
+            return;
+        this.refreshCounts();
+        entry.ordinal = Math.max(this.highestOrdinal + 1, this.observedSubmitCount > this.coveredSubmitCount
+            ? this.observedSubmitCount
+            : this.coveredSubmitCount + 1);
+        this.highestOrdinal = entry.ordinal;
+        this.expectedSubmitCount = Math.max(this.expectedSubmitCount, entry.ordinal);
+        this.markBusy();
+        this.evaluateSettlement();
+    }
+    beginTurnAttempt(snapshot = {}) {
+        const receipt = new SessionTurnReceipt({
+            ...snapshot,
+            anchorSubmitCount: snapshot.anchorSubmitCount ?? this.observedSubmitCount,
+        }, true);
+        receipt.markWritten();
+        this.attachTurn(receipt);
+        if (this.stopped)
+            return receipt;
+        this.refreshCounts();
+        const startedAt = snapshot.startedAt ?? Date.now();
+        const elapsed = Date.now() - startedAt;
+        if (elapsed >= this.attemptTimeoutMs) {
+            receipt.settle("expired");
+            const entry = this.entries.get(receipt.id);
+            if (entry)
+                this.removeEntry(entry);
+            this.evaluateSettlement({ notifyIfAlreadyIdle: true });
+            return receipt;
+        }
+        const attempt = {
+            anchorSubmitCount: snapshot.anchorSubmitCount ?? this.observedSubmitCount,
+            receipt,
+        };
+        attempt.timer = setTimeout(() => {
+            const index = this.pendingAttempts.indexOf(attempt);
+            if (index >= 0)
+                this.pendingAttempts.splice(index, 1);
+            attempt.receipt.settle("expired");
+            const entry = this.entries.get(attempt.receipt.id);
+            if (entry)
+                this.removeEntry(entry);
+            this.resolvePendingAttemptWaitersIfSettled();
+            this.evaluateSettlement();
+        }, Math.max(0, this.attemptTimeoutMs - elapsed));
+        this.pendingAttempts.push(attempt);
+        this.markBusy();
+        return receipt;
+    }
+    waitForPendingTurnAttempts() {
+        if (this.pendingAttempts.length === 0 || this.stopped)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            this.pendingAttemptWaiters.add(resolve);
+        });
+    }
+    async expectedSubmitCountFromSession() {
+        await this.registration.waitForUsableConnection({ signal: this.abort.signal });
+        this.refreshCounts();
+        return this.observedSubmitCount;
+    }
+    refreshExpiredAttempts() {
+        return Promise.resolve();
+    }
+    async refreshIdleBaseline() {
+        await this.registration.waitForUsableConnection({ signal: this.abort.signal });
+        this.refreshCounts();
+        this.coveredSubmitCount = this.observedSubmitCount;
+        this.expectedSubmitCount = Math.max(this.expectedSubmitCount, this.coveredSubmitCount);
+        this.reconcileLiveHistory();
+    }
+    classifyDeliverySince(baseline) {
+        this.refreshCounts();
+        if (baseline < 0)
+            return "unknown";
+        return this.observedSubmitCount > baseline ? "present" : "absent";
+    }
+    dispose() {
+        this.abort.abort(new Error("Copilot turn monitor disposed"));
+        this.unsubscribeEvent();
+        this.unsubscribeError();
+        for (const attempt of this.pendingAttempts) {
+            if (attempt.timer)
+                clearTimeout(attempt.timer);
+        }
+        this.pendingAttempts.length = 0;
+        for (const entry of this.entries.values())
+            entry.unsubscribe?.();
+        this.entries.clear();
+        this.resolvePendingAttemptWaiters();
+    }
+    shutdown() {
+        this.stopped = true;
+        this.dispose();
+        return Promise.resolve();
+    }
+    onEvent() {
+        if (this.stopped)
+            return;
+        const previousObserved = this.observedSubmitCount;
+        this.refreshCounts();
+        this.reconcileLiveHistory();
+        if (this.observedSubmitCount > previousObserved) {
+            this.adoptObservedSubmits(previousObserved);
+        }
+        this.evaluateSettlement();
+    }
+    adoptObservedSubmits(previousObserved) {
+        for (let i = this.pendingAttempts.length - 1; i >= 0; i--) {
+            const attempt = this.pendingAttempts[i];
+            if (this.observedSubmitCount <= attempt.anchorSubmitCount)
+                continue;
+            if (attempt.timer)
+                clearTimeout(attempt.timer);
+            const entry = this.entries.get(attempt.receipt.id);
+            if (entry && entry.ordinal === undefined) {
+                entry.ordinal = attempt.anchorSubmitCount + 1;
+                this.highestOrdinal = Math.max(this.highestOrdinal, entry.ordinal);
+                this.expectedSubmitCount = Math.max(this.expectedSubmitCount, entry.ordinal);
+            }
+            this.pendingAttempts.splice(i, 1);
+        }
+        this.resolvePendingAttemptWaitersIfSettled();
+        if (this.expectedSubmitCount < this.observedSubmitCount) {
+            this.expectedSubmitCount = this.observedSubmitCount;
+        }
+        if (this.observedSubmitCount > previousObserved)
+            this.markBusy();
+    }
+    refreshCounts() {
+        this.observedSubmitCount = this.registration.evidence.submitCount;
+    }
+    evaluateSettlement(options = {}) {
+        const evidence = this.registration.evidence;
+        this.observedSubmitCount = evidence.submitCount;
+        if (this.observedSubmitCount > this.coveredSubmitCount
+            && (evidence.settled || evidence.abortIndex >= 0)) {
+            this.coveredSubmitCount = this.observedSubmitCount;
+        }
+        const settlement = evidence.abortIndex >= 0 ? "cancelled" : "completed";
+        for (const entry of this.entries.values()) {
+            if (entry.ordinal !== undefined
+                && entry.ordinal <= this.coveredSubmitCount
+                && !entry.receipt.settlement) {
+                entry.receipt.settle(settlement);
+                this.removeEntry(entry);
+            }
+        }
+        if (this.coveredSubmitCount < this.expectedSubmitCount
+            || this.pendingAttempts.length > 0) {
+            return;
+        }
+        const wasBusy = this.busy;
+        this.busy = false;
+        if ((wasBusy || options.notifyIfAlreadyIdle === true) && !this.stopped) {
+            this.opts.onChange?.(true);
+        }
+    }
+    reconcileLiveHistory() {
+        const evidence = this.registration.evidence;
+        if (this.historyRevision === evidence.rewriteGeneration)
+            return;
+        if (this.historyRevision === undefined && !this.historySnapshot && evidence.rewriteGeneration === 0) {
+            this.historyRevision = 0;
+            return;
+        }
+        const current = evidence.snapshot(this.registration);
+        const previous = this.historySnapshot;
+        const previousRevision = this.historyRevision;
+        this.historyRevision = evidence.rewriteGeneration;
+        this.historySnapshot = undefined;
+        const comparable = previous && compatibleLiveHistorySnapshot(previous, current);
+        // An incompatible checkpoint says nothing about this launch's work. Start
+        // at its logical origin so even rewrites accepted before monitor creation count.
+        const baseline = comparable ? previous : new CopilotLiveEvidence().snapshot({
+            launchId: this.registration.launchId, sessionId: this.registration.sessionId, eventCount: 0,
+        });
+        const regression = previousRevision === undefined
+            ? compareLiveHistorySnapshots(baseline, current)
+            : {
+                commonSubmitCount: 0, currentSubmitCount: current.submitCount,
+                currentLineCount: current.lineCount,
+                removedSubmitIdentities: evidence.removedSubmitIdentities,
+            };
+        if (!regression)
+            return;
+        this.coveredSubmitCount = Math.min(this.coveredSubmitCount, regression.commonSubmitCount);
+        this.expectedSubmitCount = Math.min(this.expectedSubmitCount, regression.commonSubmitCount);
+        this.observedSubmitCount = Math.min(this.observedSubmitCount, regression.commonSubmitCount);
+        this.highestOrdinal = Math.min(this.highestOrdinal, regression.commonSubmitCount);
+        for (const attempt of this.pendingAttempts) {
+            attempt.anchorSubmitCount = Math.min(attempt.anchorSubmitCount, regression.commonSubmitCount);
+        }
+        for (const entry of this.entries.values()) {
+            if (entry.ordinal !== undefined && entry.ordinal > regression.commonSubmitCount) {
+                this.removeEntry(entry);
+                entry.receipt.settle("removed");
+            }
+        }
+        this.opts.onHistoryRegression?.(regression, current);
+    }
+    markBusy() {
+        if (this.busy)
+            return;
+        this.busy = true;
+        this.opts.onChange?.(false);
+    }
+    resolvePendingAttemptWaitersIfSettled() {
+        if (this.pendingAttempts.length === 0)
+            this.resolvePendingAttemptWaiters();
+    }
+    resolvePendingAttemptWaiters() {
+        for (const resolve of this.pendingAttemptWaiters)
+            resolve();
+        this.pendingAttemptWaiters.clear();
+    }
+    removeEntry(entry) {
+        entry.unsubscribe?.();
+        this.entries.delete(entry.receipt.id);
+    }
+}
+export async function prepareCopilotLaunchObserver(opts) {
+    return CopilotProcessObserver.create(opts);
+}
+export class CopilotLiveCompletionDetector {
+    registration;
+    opts;
+    unsubscribeEvent;
+    unsubscribeError;
+    markerTimer;
+    resolve;
+    reject;
+    startIndex = 0;
+    completed = false;
+    activationFired = false;
+    nativePlan;
+    disposed = false;
+    readingPlan = false;
+    abort = new AbortController();
+    responseParts = [];
+    captureEvents = [];
+    captureCalls = new Set();
+    constructor(registration, opts = {}) {
+        this.registration = registration;
+        this.opts = opts;
+    }
+    start(_sessionFile, lineOffset = 0) {
+        this.startIndex = Math.max(this.registration.eventCount, lineOffset);
+        return new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+            this.unsubscribeEvent = this.registration.onEvent((event) => {
+                void this.onEvent(event);
+            });
+            this.unsubscribeError = this.registration.onError((error) => {
+                this.finishError(error);
+            });
+            if (this.opts.completionMarkerFile) {
+                this.markerTimer = setInterval(() => this.checkMarker(), 100);
+                this.checkMarker();
+            }
+            void this.evaluate();
+        });
+    }
+    onPtyData(_data) {
+        // Completion is event-driven for Copilot live observation.
+    }
+    dispose() {
+        this.disposed = true;
+        this.abort.abort(new Error("Copilot completion detector disposed"));
+        this.unsubscribeEvent?.();
+        this.unsubscribeError?.();
+        this.unsubscribeEvent = undefined;
+        this.unsubscribeError = undefined;
+        if (this.markerTimer)
+            clearInterval(this.markerTimer);
+        this.markerTimer = undefined;
+    }
+    getClarifications() {
+        try {
+            return extractCopilotClarifications(this.captureEvents);
+        }
+        catch (err) {
+            if (err instanceof CopilotQACaptureError)
+                throw err;
+            throw err instanceof Error ? err : new Error(String(err));
+        }
+    }
+    getNativePlanResult() {
+        return this.nativePlan;
+    }
+    async onEvent(event) {
+        if (this.completed || this.disposed || this.registration.eventCount <= this.startIndex)
+            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);
+        }
+        const callId = stringProp(data, "toolCallId");
+        if (event.type === "tool.execution_start" && data?.toolName === "ask_user") {
+            this.captureEvents.push(event);
+            if (callId)
+                this.captureCalls.add(callId);
+        }
+        else if (event.type === "tool.execution_complete" && callId && this.captureCalls.delete(callId)) {
+            this.captureEvents.push(event);
+        }
+        if (this.opts.planMode && isExitPlanRequested(event)) {
+            if (this.readingPlan)
+                return;
+            const inlinePlan = nativePlanFromExitEvent(event);
+            if (inlinePlan?.content || inlinePlan?.path) {
+                this.nativePlan = inlinePlan;
+                this.finishSuccess(inlinePlan.content ?? "");
+                return;
+            }
+            this.readingPlan = true;
+            try {
+                this.nativePlan = await readPlanWithRetry(this.registration, this.abort.signal);
+                if (this.disposed)
+                    return;
+                this.finishSuccess(this.nativePlan.content ?? "");
+            }
+            catch (err) {
+                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;
+        }
+        if (evidence.submitIndex < this.startIndex || !evidence.settled)
+            return;
+        this.finishSuccess(this.responseParts.join("\n"));
+    }
+    checkMarker() {
+        if (this.completed || !this.opts.completionMarkerFile)
+            return;
+        let markerPresent = false;
+        try {
+            markerPresent = existsSync(this.opts.completionMarkerFile);
+        }
+        catch {
+            markerPresent = false;
+        }
+        if (!markerPresent)
+            return;
+        this.finishSuccess(this.responseParts.join("\n"));
+    }
+    fireActivationIfNeeded() {
+        if (this.activationFired)
+            return;
+        this.activationFired = true;
+        this.opts.onActivation?.();
+    }
+    finishSuccess(text) {
+        if (this.completed)
+            return;
+        this.completed = true;
+        this.dispose();
+        this.resolve?.(text);
+    }
+    finishError(error) {
+        if (this.completed || this.disposed)
+            return;
+        this.completed = true;
+        this.dispose();
+        this.reject?.(error);
+    }
+}
+async function readPlanWithRetry(registration, signal) {
+    const deadline = Date.now() + PLAN_READ_TIMEOUT_MS;
+    let last;
+    while (Date.now() < deadline) {
+        throwIfAborted(signal);
+        last = await registration.requestPlanRead(Math.max(1, deadline - Date.now()));
+        throwIfAborted(signal);
+        if (last.content || last.path)
+            return last;
+        await abortableSleep(Math.min(PLAN_READ_RETRY_MS, Math.max(0, deadline - Date.now())), signal);
+    }
+    return last ?? {};
+}
+function isSessionIdle(line, sessionId) {
+    if (line.type !== "session.idle")
+        return false;
+    const id = sessionIdFromEvent(line);
+    return !id || id === 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;
+    const data = recordProp(line, "data");
+    if (!data)
+        return undefined;
+    const content = rawStringProp(data, "planContent");
+    const path = rawStringProp(data, "path")
+        ?? rawStringProp(data, "filePath")
+        ?? rawStringProp(data, "resolvedPath");
+    if (content === undefined && path === undefined)
+        return undefined;
+    return {
+        ...(content !== undefined && { content }),
+        ...(path !== undefined && { path }),
+    };
+}
+function parseInbound(value) {
+    if (!isRecord(value))
+        throw new Error("Copilot observer message must be a JSON object");
+    if (value.kind === "auth") {
+        const launchId = stringProp(value, "launchId");
+        const sessionId = stringProp(value, "sessionId");
+        const credential = stringProp(value, "credential");
+        const runSecret = stringProp(value, "runSecret");
+        if (!launchId || !sessionId || !credential || !runSecret) {
+            throw new Error("Copilot observer auth message is missing required fields");
+        }
+        return {
+            kind: "auth",
+            launchId,
+            sessionId,
+            credential,
+            runSecret,
+            extensionPath: stringProp(value, "extensionPath"),
+        };
+    }
+    if (value.kind === "control") {
+        const type = stringProp(value, "type");
+        if (!type)
+            throw new Error("Copilot observer control message is missing type");
+        return {
+            kind: "control",
+            type,
+            sessionId: stringProp(value, "sessionId"),
+            workspacePath: stringProp(value, "workspacePath"),
+            error: stringProp(value, "error"),
+            eventIds: value.eventIds,
+        };
+    }
+    if (value.kind === "event") {
+        const seq = value.seq;
+        if (!Number.isInteger(seq) || Number(seq) <= 0 || !isRecord(value.event)) {
+            throw new Error("Copilot observer event message is malformed");
+        }
+        return {
+            kind: "event",
+            seq: Number(seq),
+            event: value.event,
+            sessionId: stringProp(value, "sessionId"),
+        };
+    }
+    if (value.kind === "rpc.response") {
+        const requestId = stringProp(value, "requestId");
+        if (!requestId || typeof value.ok !== "boolean") {
+            throw new Error("Copilot observer RPC response is malformed");
+        }
+        return {
+            kind: "rpc.response",
+            requestId,
+            ok: value.ok,
+            result: value.result,
+            error: stringProp(value, "error"),
+        };
+    }
+    throw new Error("Copilot observer sent an unknown message kind");
+}
+function parsePlanReadResult(value) {
+    if (!isRecord(value))
+        return {};
+    const exists = value.exists;
+    if (exists === false)
+        return {};
+    return {
+        content: rawStringProp(value, "content") ?? undefined,
+        path: rawStringProp(value, "path")
+            ?? rawStringProp(value, "filePath")
+            ?? rawStringProp(value, "resolvedPath")
+            ?? undefined,
+    };
+}
+function sessionIdFromEvent(event) {
+    const data = recordProp(event, "data");
+    return stringProp(data, "sessionId") ?? stringProp(event, "sessionId");
+}
+function eventStableId(event) {
+    return stringProp(event, "id") ?? stringProp(event, "eventId");
+}
+function eventReplayKey(event) {
+    const data = recordProp(event, "data");
+    const messageId = stringProp(data, "messageId");
+    if (messageId
+        && (event.type === "user.message" || event.type === "assistant.message")) {
+        return `${event.type}:message:${messageId}`;
+    }
+    const toolCallId = stringProp(data, "toolCallId");
+    if (toolCallId
+        && (event.type === "tool.execution_start"
+            || event.type === "tool.execution_complete")) {
+        return `${event.type}:tool:${toolCallId}`;
+    }
+    const hookInvocationId = stringProp(data, "hookInvocationId");
+    if (hookInvocationId
+        && (event.type === "hook.start" || event.type === "hook.end")) {
+        return `${event.type}:hook:${hookInvocationId}`;
+    }
+    const turnId = stringProp(data, "turnId") ?? stringProp(event, "turnId");
+    const timestamp = stringProp(event, "timestamp");
+    if (turnId
+        && timestamp
+        && (event.type === "assistant.turn_start" || event.type === "assistant.turn_end")) {
+        return `${event.type}:turn:${turnId}:timestamp:${timestamp}`;
+    }
+    return undefined;
+}
+function diagnosticEventTail(events) {
+    return events
+        .slice(-OBSERVER_DIAGNOSTIC_EVENT_TAIL_LIMIT)
+        .map(diagnosticEvent);
+}
+function diagnosticEvent(event) {
+    const data = recordProp(event, "data");
+    const input = recordProp(data, "input") ?? recordProp(event, "input");
+    const id = eventStableId(event);
+    const messageId = stringProp(data, "messageId");
+    const turnId = stringProp(data, "turnId") ?? stringProp(event, "turnId");
+    const phase = stringProp(data, "phase") ?? stringProp(event, "phase");
+    const hookType = stringProp(data, "hookType") ?? stringProp(event, "hookType");
+    const stopReason = stringProp(input, "stopReason");
+    const sessionId = sessionIdFromEvent(event);
+    return {
+        type: rawStringProp(event, "type") ?? "unknown",
+        ...(id && { id }),
+        ...(messageId && { messageId }),
+        ...(turnId && { turnId }),
+        ...(phase && { phase }),
+        ...(hookType && { hookType }),
+        ...(stopReason && { stopReason }),
+        ...(sessionId && { sessionId }),
+        ...(isAgentScoped(event) && { agentScoped: true }),
+    };
+}
+function isLiveHistoryRewriteEvent(line) {
+    // Compaction compresses model context, not accepted task submissions.
+    return line.type === "session.snapshot_rewind"
+        || line.type === "session.context_cleared"
+        || line.type === "session.truncation";
+}
+function validateLiveHistoryEventPayload(line) {
+    if (line.type === "session.snapshot_rewind") {
+        const data = recordProp(line, "data");
+        if (!nonNegativeIntegerProp(data, "eventsRemoved") || !stringProp(data, "upToEventId")) {
+            return "Copilot observer received malformed session.snapshot_rewind payload";
+        }
+    }
+    else if (line.type === "session.context_cleared") {
+        const data = recordProp(line, "data");
+        if (!nonNegativeIntegerProp(data, "messagesCleared")) {
+            return "Copilot observer received malformed session.context_cleared payload";
+        }
+        const initialMessage = data?.initialMessage;
+        if (initialMessage !== undefined && typeof initialMessage !== "string") {
+            return "Copilot observer received malformed session.context_cleared initialMessage";
+        }
+    }
+    else if (line.type === "session.truncation") {
+        const data = recordProp(line, "data");
+        const required = [
+            "messagesRemovedDuringTruncation",
+            "preTruncationMessagesLength",
+            "postTruncationMessagesLength",
+            "preTruncationTokensInMessages",
+            "postTruncationTokensInMessages",
+            "tokenLimit",
+            "tokensRemovedDuringTruncation",
+        ];
+        if (required.some((key) => !nonNegativeIntegerProp(data, key))) {
+            return "Copilot observer received malformed session.truncation payload";
+        }
+        if (!stringProp(data, "performedBy")) {
+            return "Copilot observer received malformed session.truncation performedBy";
+        }
+    }
+    else if (line.type === "session.compaction_complete") {
+        const data = recordProp(line, "data");
+        if (typeof data?.success !== "boolean") {
+            return "Copilot observer received malformed session.compaction_complete payload";
+        }
+        const messagesRemoved = data.messagesRemoved;
+        if (messagesRemoved !== undefined
+            && (!Number.isInteger(messagesRemoved) || Number(messagesRemoved) < 0)) {
+            return "Copilot observer received malformed session.compaction_complete messagesRemoved";
+        }
+    }
+    return undefined;
+}
+function liveSubmitIdentity(line, index, rewriteGeneration) {
+    const eventId = stringProp(line, "id");
+    if (eventId)
+        return `${rewriteGeneration}:${eventId}`;
+    const data = recordProp(line, "data");
+    const messageId = stringProp(data, "messageId") ?? stringProp(line, "messageId");
+    if (messageId)
+        return `${rewriteGeneration}:${messageId}`;
+    return `${rewriteGeneration}:${index}`;
+}
+function compatibleLiveHistorySnapshot(snapshot, current) {
+    const value = snapshot.value;
+    return isRecord(value)
+        && value.kind === "copilot-live-observer-v2"
+        && value.launchId === current.value.launchId
+        && value.sessionId === current.value.sessionId
+        && nonNegativeIntegerProp(value, "rewriteGeneration")
+        && nonNegativeIntegerProp(value, "lineCount")
+        && value.lineCount === snapshot.lineCount
+        && Array.isArray(value.submitIdentities)
+        && snapshot.submitCount === value.submitIdentities.length
+        && snapshot.submitIdentities.length === value.submitIdentities.length
+        && value.submitIdentities.every((identity, index) => typeof identity === "string" && identity === snapshot.submitIdentities[index]);
+}
+function compareLiveHistorySnapshots(previous, current) {
+    let commonSubmitCount = 0;
+    const limit = Math.min(previous.submitIdentities.length, current.submitIdentities.length);
+    while (commonSubmitCount < limit
+        && previous.submitIdentities[commonSubmitCount]
+            === current.submitIdentities[commonSubmitCount]) {
+        commonSubmitCount++;
+    }
+    if (current.value.rewriteGeneration === previous.value.rewriteGeneration
+        && current.submitCount >= previous.submitCount
+        && commonSubmitCount === previous.submitIdentities.length
+        && current.lineCount >= previous.lineCount) {
+        return undefined;
+    }
+    const currentSubmitIdentities = new Set(current.submitIdentities);
+    return {
+        commonSubmitCount,
+        currentSubmitCount: current.submitCount,
+        currentLineCount: current.lineCount,
+        removedSubmitIdentities: previous.submitIdentities.filter((identity) => !currentSubmitIdentities.has(identity)),
+    };
+}
+function nonNegativeIntegerProp(record, key) {
+    const value = record?.[key];
+    return Number.isInteger(value) && Number(value) >= 0;
+}
+function isAgentScoped(line) {
+    return stringProp(line, "agentId") !== undefined;
+}
+function token() {
+    return randomBytes(32).toString("base64url");
+}
+function sdkDistDir(resolvedExtensionEntry) {
+    const parent = dirname(resolvedExtensionEntry);
+    return basename(parent) === "cjs" ? dirname(parent) : parent;
+}
+async function createEndpoint() {
+    const id = randomUUID();
+    if (process.platform === "win32") {
+        return `\\\\.\\pipe\\poly-weaver-copilot-${id}`;
+    }
+    const dir = await mkdtemp(join(tmpdir(), "poly-weaver-copilot-broker-"));
+    return join(dir, "observer.sock");
+}
+function cleanupReadyWaiter(waiter) {
+    if (waiter.signal && waiter.onAbort) {
+        waiter.signal.removeEventListener("abort", waiter.onAbort);
+    }
+}
+//# sourceMappingURL=observation.js.map