nudge-ui 0.2.0

package/dist/inspector/agent/connectionStatus.d.ts

@@ -0,0 +1,13 @@
+import type { AgentClientSnapshot } from "./client.js";
+export type AgentConnectionStatusKind = "unavailable" | "connecting" | "working-disconnected" | "working" | "not-found" | "ready-to-connect" | "connected-not-listening" | "listening";
+export interface AgentConnectionStatus {
+    readonly kind: AgentConnectionStatusKind;
+    readonly label: string;
+    readonly tone: "neutral" | "accent" | "warning" | "danger";
+    readonly action?: {
+        readonly kind: "connect" | "setup";
+        readonly label: "Connect" | "Set up";
+    };
+}
+/** Returns the user-facing connection state shared by the prompt UI and MCP panel. */
+export declare function getAgentConnectionStatus(snapshot: AgentClientSnapshot): AgentConnectionStatus;

package/dist/inspector/agent/connectionStatus.js

@@ -0,0 +1,35 @@
+/** Returns the user-facing connection state shared by the prompt UI and MCP panel. */
+export function getAgentConnectionStatus(snapshot) {
+    if (snapshot.state === "disabled") {
+        return { kind: "unavailable", label: "Unavailable in this build", tone: "neutral" };
+    }
+    if (snapshot.state === "pairing") {
+        return { kind: "connecting", label: "Connecting…", tone: "accent" };
+    }
+    if (!snapshot.paired && (snapshot.state === "working" || snapshot.request?.status === "working")) {
+        return { kind: "working-disconnected", label: "Disconnected · Last work status unknown", tone: "warning" };
+    }
+    if (snapshot.paired && (snapshot.state === "working" || snapshot.request?.status === "working")) {
+        return { kind: "working", label: "Connected · Agent working", tone: "accent" };
+    }
+    if (snapshot.paired && !snapshot.listenerActive) {
+        return {
+            kind: "connected-not-listening",
+            label: "Connected, not listening",
+            tone: "accent",
+            action: { kind: "setup", label: "Set up" },
+        };
+    }
+    if (!snapshot.companionReachable) {
+        return { kind: "not-found", label: "Companion not found", tone: "neutral" };
+    }
+    if (snapshot.listenerActive) {
+        return { kind: "listening", label: "Agent listening", tone: "accent" };
+    }
+    return {
+        kind: "ready-to-connect",
+        label: "Ready to connect agent",
+        tone: "accent",
+        action: { kind: "connect", label: "Connect" },
+    };
+}

package/dist/inspector/agent/httpTransport.d.ts

@@ -0,0 +1,21 @@
+import { type AgentBridgeTransport, type AgentBridgeEndpointConfig, type AgentDiscoveryRequest, type AgentEventHandlers, type AgentEventSubscription, type AgentEventsRequest, type AgentPairRequest, type AgentPromptDispatch, type AgentDisconnectRequest, type AgentCanvasAcknowledgementRequest, type AgentSessionRequest, type AgentStatusSnapshot, type PairingResponse, type PromptDispatchResponse } from "./protocol.js";
+/**
+ * HTTP/SSE browser adapter for the companion's canonical endpoints.
+ *
+ * The adapter is inert when no endpoint is configured. A host can publish an
+ * endpoint with `window.__NUDGE_UI_AGENT_BRIDGE__` or the meta tag named
+ * `nudge-ui-agent-bridge`; tests can inject a transport directly instead.
+ */
+export declare class HttpAgentBridgeTransport implements AgentBridgeTransport {
+    private readonly config;
+    constructor(config?: AgentBridgeEndpointConfig);
+    discover(request: AgentDiscoveryRequest, signal?: AbortSignal): Promise<AgentStatusSnapshot | null>;
+    pair(request: AgentPairRequest, signal?: AbortSignal): Promise<PairingResponse>;
+    restore(request: AgentSessionRequest, signal?: AbortSignal): Promise<AgentStatusSnapshot | null>;
+    openEvents(request: AgentEventsRequest, handlers: AgentEventHandlers): AgentEventSubscription;
+    dispatch(request: AgentPromptDispatch, signal?: AbortSignal): Promise<PromptDispatchResponse>;
+    disconnect(request: AgentDisconnectRequest, signal?: AbortSignal): Promise<void>;
+    acknowledgeCanvasCommand(request: AgentCanvasAcknowledgementRequest, signal?: AbortSignal): Promise<void>;
+}
+/** Resolve host configuration without touching the network. */
+export declare function getConfiguredAgentBridgeEndpoint(): AgentBridgeEndpointConfig | undefined;

package/dist/inspector/agent/httpTransport.js

@@ -0,0 +1,347 @@
+import { AGENT_PROTOCOL_VERSION, defaultBridgePort, } from "./protocol.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function endpointValue(value) {
+    if (!isRecord(value))
+        return undefined;
+    const config = {
+        baseUrl: stringValue(value.baseUrl),
+        healthUrl: stringValue(value.healthUrl),
+        pairUrl: stringValue(value.pairUrl),
+        eventsUrl: stringValue(value.eventsUrl),
+        promptUrl: stringValue(value.promptUrl),
+        statusUrl: stringValue(value.statusUrl),
+        canvasAckUrl: stringValue(value.canvasAckUrl),
+        disconnectUrl: stringValue(value.disconnectUrl),
+    };
+    return Object.values(config).some((entry) => entry !== undefined) ? config : undefined;
+}
+function configuredEndpoint() {
+    if (typeof window === "undefined")
+        return undefined;
+    const target = window;
+    const globalConfig = endpointValue(target.__NUDGE_UI_AGENT_BRIDGE__)
+        ?? endpointValue(target.__NUDGE_UI_AGENT__);
+    if (globalConfig)
+        return globalConfig;
+    const meta = document.querySelector('meta[name="nudge-ui-agent-bridge"]');
+    const content = meta?.content.trim();
+    return content ? { baseUrl: content } : undefined;
+}
+function isLoopback(hostname) {
+    const normalized = hostname.toLowerCase();
+    return normalized === "localhost"
+        || normalized === "127.0.0.1"
+        || normalized === "[::1]"
+        || normalized === "::1";
+}
+function pageOrigin() {
+    return typeof window !== "undefined" && window.location.origin
+        ? window.location.origin
+        : "http://localhost";
+}
+function safeUrl(value, origin) {
+    try {
+        const url = new URL(value, origin);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            return null;
+        // A same-origin reverse proxy is valid; a separately hosted bridge must
+        // remain loopback-only to match ADR-0013.
+        if (url.origin !== origin && !isLoopback(url.hostname))
+            return null;
+        return url;
+    }
+    catch {
+        return null;
+    }
+}
+function endpointUrl(config, projectId, key, fallbackPath, origin) {
+    const explicit = config[key];
+    if (explicit && key !== "baseUrl")
+        return safeUrl(explicit, origin);
+    const baseValue = config.baseUrl ?? `http://127.0.0.1:${defaultBridgePort(projectId)}`;
+    const base = safeUrl(baseValue, origin);
+    if (!base)
+        return null;
+    base.pathname = `${base.pathname.replace(/\/$/, "")}${fallbackPath}`;
+    return base;
+}
+function withQuery(url, values) {
+    const result = new URL(url.href);
+    for (const [key, value] of Object.entries(values))
+        result.searchParams.set(key, value);
+    return result;
+}
+function headers() {
+    return {
+        Accept: "application/json",
+    };
+}
+async function readJson(response) {
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        payload = {};
+    }
+    if (!response.ok) {
+        const error = isRecord(payload) && isRecord(payload.error) ? payload.error : payload;
+        const message = isRecord(error) ? stringValue(error.message) : undefined;
+        throw new Error(message ?? `Agent bridge request failed (${response.status}).`);
+    }
+    return isRecord(payload) ? payload : {};
+}
+function statusPayload(value) {
+    if (!isRecord(value))
+        return null;
+    const status = isRecord(value.status) ? value.status : value;
+    if (typeof status.projectId !== "string"
+        || (status.connection !== "offline"
+            && status.connection !== "listening"
+            && status.connection !== "paired"
+            && status.connection !== "working")
+        || typeof status.listenerActive !== "boolean"
+        || typeof status.paired !== "boolean")
+        return null;
+    if (status.protocolVersion !== undefined && status.protocolVersion !== AGENT_PROTOCOL_VERSION)
+        return null;
+    const rawRequest = status.request;
+    let request = null;
+    if (rawRequest !== null && rawRequest !== undefined) {
+        if (!isRecord(rawRequest)
+            || typeof rawRequest.requestId !== "string"
+            || typeof rawRequest.projectId !== "string"
+            || typeof rawRequest.prompt !== "string"
+            || (rawRequest.status !== "working"
+                && rawRequest.status !== "completed"
+                && rawRequest.status !== "failed"
+                && rawRequest.status !== "interrupted"))
+            return null;
+        request = {
+            requestId: rawRequest.requestId,
+            projectId: rawRequest.projectId,
+            prompt: rawRequest.prompt,
+            status: rawRequest.status,
+            ...(typeof rawRequest.changeRevision === "number" ? { changeRevision: rawRequest.changeRevision } : {}),
+            ...(typeof rawRequest.summary === "string" ? { summary: rawRequest.summary } : {}),
+            ...(typeof rawRequest.error === "string" ? { error: rawRequest.error } : {}),
+        };
+    }
+    return {
+        protocolVersion: AGENT_PROTOCOL_VERSION,
+        projectId: status.projectId,
+        connection: status.connection,
+        listenerActive: status.listenerActive,
+        paired: status.paired,
+        request,
+    };
+}
+function eventPayload(value) {
+    if (!isRecord(value))
+        return null;
+    const envelope = value;
+    const event = isRecord(envelope.event) ? envelope.event : value;
+    const type = stringValue(event.type);
+    if (type === "status") {
+        const status = statusPayload(event.status);
+        return status ? { type: "status", status } : null;
+    }
+    if (type === "connected") {
+        const status = statusPayload(event.status);
+        return status ? { type: "connected", status } : null;
+    }
+    if (type === "disconnected") {
+        return { type: "disconnected", ...(stringValue(event.reason) ? { reason: stringValue(event.reason) } : {}) };
+    }
+    if (type === "canvas-command" && isRecord(event.command)) {
+        // The Canvas controller owns command validation. Preserve the shared
+        // shape here so the parent stage can consume this event without a second
+        // protocol vocabulary.
+        return { type: "canvas-command", command: event.command };
+    }
+    return null;
+}
+function eventData(event) {
+    if (typeof event.data !== "string")
+        return event.data;
+    try {
+        return JSON.parse(event.data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * HTTP/SSE browser adapter for the companion's canonical endpoints.
+ *
+ * The adapter is inert when no endpoint is configured. A host can publish an
+ * endpoint with `window.__NUDGE_UI_AGENT_BRIDGE__` or the meta tag named
+ * `nudge-ui-agent-bridge`; tests can inject a transport directly instead.
+ */
+export class HttpAgentBridgeTransport {
+    config;
+    constructor(config = configuredEndpoint() ?? {}) {
+        this.config = config;
+    }
+    async discover(request, signal) {
+        const url = endpointUrl(this.config, request.projectId, "healthUrl", "/health", pageOrigin());
+        if (!url || typeof fetch !== "function")
+            return null;
+        const response = await fetch(withQuery(url, {
+            projectId: request.projectId,
+        }), {
+            method: "GET",
+            headers: headers(),
+            signal,
+        });
+        const payload = await readJson(response);
+        if (payload.protocolVersion !== AGENT_PROTOCOL_VERSION
+            || payload.projectId !== request.projectId
+            || (payload.origin !== undefined && payload.origin !== null && payload.origin !== request.origin))
+            return null;
+        return statusPayload(payload.status);
+    }
+    async pair(request, signal) {
+        const url = endpointUrl(this.config, request.projectId, "pairUrl", "/pair", pageOrigin());
+        if (!url || typeof fetch !== "function")
+            throw new Error("Agent bridge is unavailable.");
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { ...headers(), "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+            signal,
+        });
+        const payload = await readJson(response);
+        if (payload.protocolVersion !== AGENT_PROTOCOL_VERSION
+            || payload.projectId !== request.projectId
+            || payload.origin !== request.origin
+            || typeof payload.sessionToken !== "string") {
+            throw new Error("Agent bridge returned an invalid pairing response.");
+        }
+        const status = statusPayload(payload.status);
+        if (!status)
+            throw new Error("Agent bridge returned an invalid status.");
+        return {
+            protocolVersion: AGENT_PROTOCOL_VERSION,
+            projectId: request.projectId,
+            origin: request.origin,
+            sessionToken: payload.sessionToken,
+            status,
+        };
+    }
+    async restore(request, signal) {
+        const url = endpointUrl(this.config, request.projectId, "statusUrl", "/status", pageOrigin());
+        if (!url || typeof fetch !== "function")
+            return null;
+        const response = await fetch(withQuery(url, {
+            projectId: request.projectId,
+            sessionToken: request.sessionToken,
+        }), { method: "GET", headers: headers(), signal });
+        const payload = await readJson(response);
+        if (payload.protocolVersion !== AGENT_PROTOCOL_VERSION || payload.projectId !== request.projectId)
+            return null;
+        const status = statusPayload(payload);
+        if (!status || !status.paired)
+            return null;
+        return status;
+    }
+    openEvents(request, handlers) {
+        const url = endpointUrl(this.config, request.projectId, "eventsUrl", "/events", pageOrigin());
+        if (!url || typeof EventSource !== "function") {
+            queueMicrotask(() => handlers.onDisconnect("Agent event transport is unavailable."));
+            return { close: () => undefined };
+        }
+        const eventUrl = withQuery(url, {
+            projectId: request.projectId,
+            sessionToken: request.sessionToken,
+        });
+        const source = new EventSource(eventUrl.href);
+        let closed = false;
+        const handleMessage = (event) => {
+            const parsed = eventPayload(eventData(event));
+            if (parsed)
+                handlers.onEvent(parsed);
+        };
+        source.addEventListener("message", handleMessage);
+        source.addEventListener("status", handleMessage);
+        source.addEventListener("connected", handleMessage);
+        source.addEventListener("disconnected", handleMessage);
+        source.addEventListener("canvas-command", handleMessage);
+        source.onerror = () => {
+            if (closed)
+                return;
+            closed = true;
+            source.close();
+            handlers.onDisconnect("Agent event stream disconnected.");
+        };
+        return {
+            close: () => {
+                if (closed)
+                    return;
+                closed = true;
+                source.close();
+            },
+        };
+    }
+    async dispatch(request, signal) {
+        const url = endpointUrl(this.config, request.projectId, "promptUrl", "/prompt", pageOrigin());
+        if (!url || typeof fetch !== "function")
+            throw new Error("Agent bridge is unavailable.");
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { ...headers(), "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+            signal,
+        });
+        const payload = await readJson(response);
+        if (!isRecord(payload.request)
+            || typeof payload.request.requestId !== "string"
+            || typeof payload.request.projectId !== "string"
+            || typeof payload.request.prompt !== "string"
+            || payload.status !== "working") {
+            throw new Error("Agent bridge returned an invalid prompt response.");
+        }
+        const requestBody = {
+            requestId: payload.request.requestId,
+            projectId: payload.request.projectId,
+            prompt: payload.request.prompt,
+            ...(typeof payload.request.changeRevision === "number" ? { changeRevision: payload.request.changeRevision } : {}),
+        };
+        return { request: requestBody, status: "working" };
+    }
+    async disconnect(request, signal) {
+        const url = endpointUrl(this.config, request.projectId, "disconnectUrl", "/disconnect", pageOrigin());
+        if (!url || typeof fetch !== "function")
+            return;
+        await fetch(url, {
+            method: "POST",
+            headers: { ...headers(), "Content-Type": "application/json" },
+            body: JSON.stringify(request),
+            signal,
+        });
+    }
+    async acknowledgeCanvasCommand(request, signal) {
+        const url = endpointUrl(this.config, request.projectId, "canvasAckUrl", "/canvas/ack", pageOrigin());
+        if (!url || typeof fetch !== "function")
+            return;
+        await fetch(url, {
+            method: "POST",
+            headers: { ...headers(), "Content-Type": "application/json" },
+            body: JSON.stringify({
+                projectId: request.projectId,
+                sessionToken: request.sessionToken,
+                ...request.acknowledgement,
+            }),
+            signal,
+        });
+    }
+}
+/** Resolve host configuration without touching the network. */
+export function getConfiguredAgentBridgeEndpoint() {
+    return configuredEndpoint();
+}

package/dist/inspector/agent/protocol.d.ts

@@ -0,0 +1,95 @@
+import type { AgentStatusSnapshot, CanvasCommand, CanvasCommandAcknowledgement, CanvasCommandResult, PairingResponse, PromptDispatchResponse } from "../../internal/agent-protocol.js";
+/**
+ * Browser transport port for the shared Nudge agent protocol.
+ *
+ * Domain messages come from the private shared protocol module; this file only
+ * adds the browser's injectable HTTP/SSE transport boundary. Keeping that
+ * boundary local lets inspector tests use a deterministic fake while the
+ * companion remains the owner of MCP and Node-specific code.
+ */
+export { AGENT_PROTOCOL_LIMITS, AGENT_PROTOCOL_VERSION, defaultBridgePort, CANVAS_COMMAND_TYPES, canonicalOrigin, isAgentPromptRequest, isAgentStatusUpdate, isAllowedOrigin, isCanvasCommand, isCanvasGroup, isCanvasState, isCanonicalOrigin, isProjectIdentity, isSameOriginRoute, protocolError, validateRoutes, } from "../../internal/agent-protocol.js";
+export type { AgentConnectionState, AgentProjectIdentity, AgentPromptRequest, AgentRequestOutcome, AgentRequestStatus, AgentRoute, AgentStatusSnapshot, AgentStatusUpdate, BridgeCanvasCommandEvent, BridgeConnectedEvent, BridgeDisconnectedEvent, BridgeEnvelope, BridgeEvent, BridgeEventType, BridgeStatusEvent, CanvasCommand, CanvasCommandAcknowledgement, CanvasCommandError, CanvasCommandResult, CanvasGroup, CanvasGroupOwner, CanvasState, FitCanvasCommand, FocusCanvasGroupCommand, PairingRequest, PairingResponse, PresentRoutesCommand, PromptDispatchRequest, PromptDispatchResponse, ReadCanvasStateCommand, RemoveCanvasGroupCommand, StatusEventRequest, AgentProtocolVersion, } from "../../internal/agent-protocol.js";
+export interface AgentBridgeEndpointConfig {
+    readonly baseUrl?: string;
+    readonly healthUrl?: string;
+    readonly pairUrl?: string;
+    readonly eventsUrl?: string;
+    readonly promptUrl?: string;
+    readonly statusUrl?: string;
+    readonly canvasAckUrl?: string;
+    readonly disconnectUrl?: string;
+}
+export interface AgentDiscoveryRequest {
+    readonly projectId: string;
+    readonly origin: string;
+}
+export interface AgentPairRequest {
+    readonly projectId: string;
+    readonly origin: string;
+    readonly pageUrl?: string;
+}
+export interface AgentEventsRequest {
+    readonly projectId: string;
+    readonly origin: string;
+    readonly sessionToken: string;
+}
+export interface AgentSessionRequest {
+    readonly projectId: string;
+    readonly origin: string;
+    readonly sessionToken: string;
+}
+export interface AgentPromptDispatch {
+    readonly projectId: string;
+    readonly sessionToken: string;
+    readonly prompt: string;
+    readonly changeRevision?: number;
+}
+export interface AgentDisconnectRequest {
+    readonly projectId: string;
+    readonly origin: string;
+    readonly sessionToken: string;
+}
+export interface AgentCanvasAcknowledgementRequest {
+    readonly projectId: string;
+    readonly origin: string;
+    readonly sessionToken: string;
+    readonly acknowledgement: CanvasCommandAcknowledgement;
+}
+export interface AgentEventHandlers {
+    readonly onEvent: (event: AgentBridgeEvent) => void;
+    readonly onDisconnect: (reason?: string) => void;
+}
+export interface AgentEventSubscription {
+    readonly close: () => void;
+}
+/** Events delivered by the companion's SSE stream. */
+export type AgentBridgeEvent = {
+    readonly type: "status";
+    readonly status: AgentStatusSnapshot;
+} | {
+    readonly type: "connected";
+    readonly status: AgentStatusSnapshot;
+} | {
+    readonly type: "disconnected";
+    readonly reason?: string;
+} | {
+    readonly type: "canvas-command";
+    readonly command: CanvasCommand;
+};
+export interface AgentBridgeTransport {
+    readonly discover: (request: AgentDiscoveryRequest, signal?: AbortSignal) => Promise<AgentStatusSnapshot | null>;
+    readonly restore?: (request: AgentSessionRequest, signal?: AbortSignal) => Promise<AgentStatusSnapshot | null>;
+    readonly pair: (request: AgentPairRequest, signal?: AbortSignal) => Promise<PairingResponse>;
+    readonly openEvents: (request: AgentEventsRequest, handlers: AgentEventHandlers) => AgentEventSubscription;
+    readonly dispatch: (request: AgentPromptDispatch, signal?: AbortSignal) => Promise<PromptDispatchResponse | null>;
+    readonly disconnect?: (request: AgentDisconnectRequest, signal?: AbortSignal) => Promise<void>;
+    readonly acknowledgeCanvasCommand?: (request: AgentCanvasAcknowledgementRequest, signal?: AbortSignal) => Promise<void>;
+}
+export interface AgentClientOptions {
+    readonly projectId: string;
+    readonly origin?: string;
+    readonly transport?: AgentBridgeTransport;
+    readonly endpoint?: AgentBridgeEndpointConfig;
+    readonly discoveryIntervalMs?: number;
+    readonly canvasCommandHandler?: (command: CanvasCommand) => CanvasCommandResult | Promise<CanvasCommandResult>;
+}

package/dist/inspector/agent/protocol.js

@@ -0,0 +1,9 @@
+/**
+ * Browser transport port for the shared Nudge agent protocol.
+ *
+ * Domain messages come from the private shared protocol module; this file only
+ * adds the browser's injectable HTTP/SSE transport boundary. Keeping that
+ * boundary local lets inspector tests use a deterministic fake while the
+ * companion remains the owner of MCP and Node-specific code.
+ */
+export { AGENT_PROTOCOL_LIMITS, AGENT_PROTOCOL_VERSION, defaultBridgePort, CANVAS_COMMAND_TYPES, canonicalOrigin, isAgentPromptRequest, isAgentStatusUpdate, isAllowedOrigin, isCanvasCommand, isCanvasGroup, isCanvasState, isCanonicalOrigin, isProjectIdentity, isSameOriginRoute, protocolError, validateRoutes, } from "../../internal/agent-protocol.js";

package/dist/inspector/agent/verification.d.ts

@@ -0,0 +1,39 @@
+import { type ChangeRecord } from "../changes/changesLog.js";
+import { type StructuralChange } from "../projection/structuralProjection.js";
+export interface HandoffSnapshot {
+    readonly changes: readonly ChangeRecord[];
+    readonly structuralChanges: readonly StructuralChange[];
+}
+/**
+ * User-facing agent completion state, named once.
+ * "completed" means the agent finished; "verified" means completed work was
+ * positively reconciled against source-rendered output.
+ */
+export type AgentCompletionStatus = "completed" | "verified";
+/** Stable, preview-metadata-free identity for one prompt handoff record. */
+export declare function handoffChangeFingerprint(change: ChangeRecord): string;
+/** Stable identity for one structural record included in a prompt handoff. */
+export declare function handoffStructuralFingerprint(change: StructuralChange): string;
+/**
+ * Positively verifies browser-observable source results after the inspector's
+ * own projections have been removed. Component props and interaction states
+ * intentionally remain unresolved because rendered output alone cannot prove
+ * that their source was updated.
+ */
+export declare function verifiedChangeKeys(sentChanges: readonly ChangeRecord[], doc?: Document): Set<string>;
+/** Captures the exact canonical edits associated with one dispatched prompt. */
+export declare function recordAgentDispatch(revision: number, changes: readonly ChangeRecord[], structuralChanges?: readonly StructuralChange[]): void;
+/** Drops a captured revision when the bridge rejects its dispatch. */
+export declare function discardAgentDispatch(revision: number): void;
+/** Returns how many canonical edits were in flight for one dispatch. */
+export declare function getAgentDispatchSize(revision: number): number;
+/**
+ * Reconciles only records that still equal the sent snapshot and that remain
+ * observable after removing Nudge's own preview. Newer edits and ambiguous
+ * records are preserved.
+ */
+export declare function verifyAndReconcileHandoff(snapshot: HandoffSnapshot): Promise<number>;
+/** Reconciles the captured records for one completed connected-agent request. */
+export declare function verifyAndReconcileAgentDispatch(revision: number): Promise<number>;
+/** Test/session reset for in-memory dispatch snapshots. */
+export declare function resetAgentVerification(): void;