@xenosystem/agent-conversation 0.1.30

package/dist/platformApiTypes.d.ts

@@ -0,0 +1,4176 @@
+interface SpeechRecognitionEvent extends Event {
+    readonly resultIndex: number;
+    readonly results: SpeechRecognitionResultList;
+}
+interface SpeechRecognitionResultList {
+    readonly length: number;
+    item(index: number): SpeechRecognitionResult;
+    [index: number]: SpeechRecognitionResult;
+}
+interface SpeechRecognitionResult {
+    readonly isFinal: boolean;
+    readonly length: number;
+    item(index: number): SpeechRecognitionAlternative;
+    [index: number]: SpeechRecognitionAlternative;
+}
+interface SpeechRecognitionAlternative {
+    readonly transcript: string;
+    readonly confidence: number;
+}
+interface SpeechRecognitionErrorEvent extends Event {
+    readonly error: string;
+    readonly message: string;
+}
+interface SpeechRecognition extends EventTarget {
+    continuous: boolean;
+    interimResults: boolean;
+    lang: string;
+    maxAlternatives: number;
+    onresult: ((event: SpeechRecognitionEvent) => void) | null;
+    onerror: ((event: SpeechRecognitionErrorEvent) => void) | null;
+    onend: (() => void) | null;
+    onstart: (() => void) | null;
+    start(): void;
+    stop(): void;
+    abort(): void;
+}
+interface AgentContextCompactionMetrics {
+    strategyVersion: number;
+    contextDigest: string;
+    rawMessageCount: number;
+    sentMessageCount: number;
+    compactedMessageCount: number;
+    estimatedRawTokens: number;
+    estimatedSentTokens: number;
+    retainedAnchorCount: number;
+    retainedArtifactCount: number;
+    retainedGrantedDirectoryCount: number;
+}
+interface SpeechRecognitionConstructor {
+    new (): SpeechRecognition;
+}
+import type { ConversationEditorDiff } from './types/agentEditor.js';
+type ScopedIpcParams = Record<string, unknown>;
+type PathIpcInput = string | ScopedIpcParams;
+type WebSearchIpcInput = string | ({
+    query: string;
+    count?: number;
+} & ScopedIpcParams);
+type ConvertOptions = {
+    quality?: number;
+    sampleRate?: number;
+    bitsPerSample?: number;
+    compressionLevel?: number;
+};
+export type MarketplaceListingKind = 'app-native' | 'app-sandboxed' | 'panel' | 'plugin' | 'mcp' | 'model' | 'mind' | 'swarm';
+export type MarketplaceTrustTier = 'official' | 'verified' | 'community';
+export type MarketplacePricingModel = 'free' | 'one_time' | 'subscription' | 'pay_per_use' | 'rental';
+export type MarketplaceEntitlementKind = 'owned' | 'subscribed' | 'rental';
+export type MarketplaceEntitlementStatus = 'active' | 'expired' | 'revoked';
+export interface MarketplacePricing {
+    model: MarketplacePricingModel;
+    priceCredits: number | null;
+    priceUsd: number | null;
+    period: string | null;
+    meterUnit: string | null;
+}
+export interface MarketplaceListing {
+    id: string;
+    slug: string;
+    kind: MarketplaceListingKind;
+    title: string;
+    summary: string;
+    category: string | null;
+    trustTier: MarketplaceTrustTier;
+    iconUrl: string | null;
+    developerName: string | null;
+    currentVersion: string | null;
+    pricing: MarketplacePricing[];
+    rating: number | null;
+    reviewCount: number | null;
+    downloads: number | null;
+    nativeAppId?: string | null;
+    isDevFixture?: boolean;
+}
+export interface MarketplaceListingVersion {
+    version: string;
+    releaseNotes: string | null;
+    declaredCapabilities: string[];
+    publishedAt: string | null;
+}
+export interface MarketplaceListingDetail extends MarketplaceListing {
+    description: string;
+    screenshots: string[];
+    versions: MarketplaceListingVersion[];
+    reviews: Array<{
+        id: string;
+        userName: string;
+        rating: number;
+        text: string;
+        createdAt: string;
+    }>;
+    declaredCapabilities: string[];
+}
+export interface MarketplaceEntitlement {
+    listingId: string;
+    listingSlug: string | null;
+    kind: MarketplaceEntitlementKind;
+    status: MarketplaceEntitlementStatus;
+    grantedAt: string | null;
+    expiresAt: string | null;
+}
+/** Canonical host DTO; a duplicate here previously hid artifact/candidate IDs. */
+export type LandingQueueView = import('@xenosystem/agent-interface-contract').LandingQueueResponse;
+export interface XenoAPI {
+    ownedBrowser?: {
+        session(input: import('@xenosystem/agent-interface-contract').AgentBrowserSessionClientRequest): Promise<import('@xenosystem/agent-interface-contract').AgentBrowserSessionResult>;
+        command(input: Omit<import('@xenosystem/agent-interface-contract').AgentBrowserRequest, 'client'>): Promise<import('@xenosystem/agent-interface-contract').AgentBrowserResult>;
+    };
+    /** Tool-free requests are not the legacy streaming chat API. */
+    auxiliaryInference?: Pick<XenoAPI['llm'], 'chatOnce' | 'localModels' | 'localWarmup'>;
+    workspaceRules?: {
+        request(input: import('@xenosystem/agent-interface-contract').AgentWorkspaceRulesRequest): Promise<import('@xenosystem/agent-interface-contract').AgentWorkspaceRulesResult>;
+    };
+    account?: {
+        request(input: import('@xenosystem/agent-interface-contract').AgentAccountRequest): Promise<import('@xenosystem/agent-interface-contract').AgentAccountResult>;
+    };
+    workforce?: {
+        request(input: import('@xenosystem/agent-interface-contract').AgentWorkforceRequest): Promise<import('@xenosystem/agent-interface-contract').AgentWorkforceResult>;
+    };
+    notifications?: {
+        request(input: import('@xenosystem/agent-interface-contract').AgentNotificationsRequest): Promise<import('@xenosystem/agent-interface-contract').AgentNotificationsResult>;
+    };
+    window: {
+        minimize: () => Promise<void>;
+        maximize: () => Promise<void>;
+        close: () => Promise<void>;
+        isMaximized: () => Promise<boolean>;
+        openExternal: (url: string) => Promise<void>;
+        onMaximizedChange: (callback: (isMaximized: boolean) => void) => void;
+    };
+    agentHost?: {
+        request: (method: string, input: unknown) => Promise<unknown>;
+        subscribe: (callback: (event: unknown) => void) => string;
+        unsubscribe: (subscriptionId: string) => boolean;
+    };
+    debug?: {
+        log: (scope: string, message: string, meta?: Record<string, unknown>) => void;
+    };
+    perf?: {
+        rendererReady: () => Promise<{
+            success: boolean;
+            metrics: {
+                processStart: number;
+                appReady?: number;
+                windowCreated?: number;
+                windowShown?: number;
+                rendererReady?: number;
+                toAppReady?: number;
+                toWindowCreated?: number;
+                toWindowShown?: number;
+                toRendererReady?: number;
+                appVersion: string;
+                date: string;
+            };
+        }>;
+        getMetrics: () => Promise<{
+            success: boolean;
+            data: unknown;
+        }>;
+    };
+    auth: {
+        status: () => Promise<{
+            authenticated: boolean;
+        }>;
+        getWebToken: () => Promise<string | null>;
+        getApiKey: () => Promise<string | null>;
+        saveCredentials: (webToken: string) => Promise<{
+            success: boolean;
+        }>;
+        logout: () => Promise<{
+            success: boolean;
+        }>;
+        openOAuth: (provider: string) => Promise<{
+            success: boolean;
+            cancelled?: boolean;
+            user?: unknown;
+            apiKey?: string;
+            error?: string;
+        }>;
+        cancelOAuth: () => Promise<{
+            success: boolean;
+        }>;
+        loginWithEmail: (email: string, password: string) => Promise<{
+            success: boolean;
+            token?: string;
+            apiKey?: string;
+            user?: unknown;
+            error?: string;
+        }>;
+        registerWithEmail: (name: string, email: string, password: string) => Promise<{
+            success: boolean;
+            token?: string;
+            apiKey?: string;
+            user?: unknown;
+            error?: string;
+        }>;
+        validateToken: (token: string) => Promise<{
+            valid: boolean;
+            user?: unknown;
+            apiKey?: string;
+            error?: string;
+        }>;
+    };
+    content: {
+        fetchJson: (params: {
+            url: string;
+            auth?: boolean;
+            timeoutMs?: number;
+        } & ScopedIpcParams) => Promise<{
+            success: boolean;
+            status: number;
+            error: string | null;
+            data: unknown;
+        }>;
+    };
+    apps?: {
+        list: () => Promise<Array<{
+            id: string;
+            name: string;
+            description: string;
+            icon: string;
+            executable: string;
+            status: string;
+            version?: string;
+            category: string;
+        }>>;
+        get: (appId: string) => Promise<{
+            id: string;
+            name: string;
+            description: string;
+            icon: string;
+            executable: string;
+            status: string;
+            version?: string;
+            category: string;
+        } | null>;
+        launch: (appId: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        isRunning: (appId: string) => Promise<boolean>;
+        stop: (appId: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        onLaunchRequest: (callback: (appId: string) => void) => void;
+    };
+    creativeApps?: {
+        list: () => Promise<Array<{
+            id: string;
+            name: string;
+            description: string;
+            version: string;
+            installedVersion: string | null;
+            status: 'not_installed' | 'installed' | 'running' | 'update_available';
+            installPath: string | null;
+            downloadUrl: string;
+            notes: string | null;
+            category: 'studio' | 'office' | 'corpo' | 'automation';
+        }>>;
+        install: (appId: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        cancelInstall: (appId: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        launch: (appId: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        stop: (appId: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        checkUpdate: (appId: string) => Promise<{
+            available: boolean;
+            version: string;
+            installedVersion?: string;
+            notes?: string;
+        }>;
+        uninstall: (appId: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        openInstallLocation: (appId: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        onInstallProgress: (callback: (data: {
+            appId: string;
+            phase: 'downloading' | 'installing' | 'complete' | 'error';
+            percent: number;
+            bytesDownloaded: number;
+            totalBytes: number;
+            error?: string;
+        }) => void) => void;
+        offInstallProgress: () => void;
+        onStatusChanged: (callback: (data: {
+            reason: string;
+            running: Record<string, boolean>;
+            timestamp: number;
+        }) => void) => void;
+        offStatusChanged: () => void;
+    };
+    marketplace?: {
+        catalog: (params?: {
+            kind?: string;
+            category?: string;
+            trustTier?: string;
+            q?: string;
+            page?: number;
+            pageSize?: number;
+        }) => Promise<{
+            success: boolean;
+            listings: MarketplaceListing[];
+            total: number;
+            page?: number;
+            pageSize?: number;
+            devFixture?: boolean;
+            error?: string;
+        }>;
+        listing: (slug: string) => Promise<{
+            success: boolean;
+            listing?: MarketplaceListingDetail;
+            devFixture?: boolean;
+            error?: string;
+        }>;
+        entitlements: () => Promise<{
+            success: boolean;
+            entitlements: MarketplaceEntitlement[];
+            authenticated: boolean;
+            error?: string;
+        }>;
+        purchase: (params: {
+            listingId: string;
+            versionId?: string;
+        }) => Promise<{
+            success: boolean;
+            entitlement?: MarketplaceEntitlement | null;
+            transaction?: unknown;
+            error?: string;
+        }>;
+        subscribe: (params: {
+            listingId: string;
+            period?: string;
+        }) => Promise<{
+            success: boolean;
+            entitlement?: MarketplaceEntitlement | null;
+            transaction?: unknown;
+            error?: string;
+        }>;
+        rent: (params: {
+            listingId: string;
+            period?: string;
+        }) => Promise<{
+            success: boolean;
+            entitlement?: MarketplaceEntitlement | null;
+            transaction?: unknown;
+            error?: string;
+        }>;
+        install: (params: {
+            listingId: string;
+            kind: string;
+            nativeAppId?: string | null;
+            versionId?: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+            notAvailableYet?: boolean;
+        }>;
+        launch: (params: {
+            nativeAppId: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        nativeStatus: (params: {
+            nativeAppId: string;
+        }) => Promise<{
+            success: boolean;
+            status: 'not_installed' | 'installed' | 'running' | 'update_available';
+            installPath: string | null;
+            installedVersion: string | null;
+            error?: string;
+        }>;
+        invoke: (params: {
+            listingId: string;
+            input?: unknown;
+        }) => Promise<{
+            success: boolean;
+            output?: unknown;
+            usage?: unknown;
+            creditsCharged?: number | null;
+            error?: string;
+        }>;
+        openExternal: (url: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        onInstallProgress: (callback: (data: {
+            listingId: string | null;
+            appId: string;
+            kind: string;
+            phase: 'downloading' | 'installing' | 'complete' | 'error';
+            percent: number;
+            bytesDownloaded: number;
+            totalBytes: number;
+            error?: string;
+        }) => void) => void;
+        offInstallProgress: () => void;
+    };
+    pixelBridge?: {
+        status: () => Promise<{
+            success: boolean;
+            status: {
+                running: boolean;
+                processDetected: boolean;
+                bridgeReady: boolean;
+                stale: boolean;
+                activeProjectPath: string | null;
+                activeProjectName: string | null;
+                activeDocumentId: string | null;
+                activeDocumentName: string | null;
+                hasOpenDocument: boolean;
+                updatedAt: number | null;
+            };
+            error?: string;
+        }>;
+        sendImage: (params: {
+            dataUrl: string;
+            sourceName?: string;
+            layerName?: string;
+            workspaceId?: string;
+            teamId?: string;
+            agentId?: string;
+            caller?: {
+                userId?: string;
+                workspaceId?: string;
+                teamId?: string;
+                agentId?: string;
+                allowedDirectories?: string[];
+            };
+        }) => Promise<{
+            success: boolean;
+            commandId?: string;
+            error?: string;
+            policyDecision?: {
+                allowed: boolean;
+                reason: string;
+            };
+            status?: {
+                running: boolean;
+                bridgeReady: boolean;
+                hasOpenDocument: boolean;
+                activeProjectName: string | null;
+                activeDocumentName: string | null;
+            };
+        }>;
+    };
+    motionBridge?: {
+        status: () => Promise<{
+            success: boolean;
+            status: {
+                running: boolean;
+                processDetected: boolean;
+                bridgeReady: boolean;
+                stale: boolean;
+                activeProjectPath: string | null;
+                activeProjectName: string | null;
+                activeSequenceId: string | null;
+                activeSequenceName: string | null;
+                currentFrame: number | null;
+                hasOpenProject: boolean;
+                updatedAt: number | null;
+            };
+            error?: string;
+        }>;
+        sendImage: (params: {
+            dataUrl: string;
+            sourceName?: string;
+            mediaName?: string;
+            durationFrames?: number;
+            placeOnTimeline?: boolean;
+            workspaceId?: string;
+            teamId?: string;
+            agentId?: string;
+            caller?: {
+                userId?: string;
+                workspaceId?: string;
+                teamId?: string;
+                agentId?: string;
+                allowedDirectories?: string[];
+            };
+        }) => Promise<{
+            success: boolean;
+            commandId?: string;
+            error?: string;
+            policyDecision?: {
+                allowed: boolean;
+                reason: string;
+            };
+            status?: {
+                running: boolean;
+                bridgeReady: boolean;
+                hasOpenProject: boolean;
+                activeProjectName: string | null;
+                activeSequenceName: string | null;
+            };
+        }>;
+    };
+    credits?: {
+        balance: () => Promise<{
+            balance: number;
+            currency: string;
+            lastUpdated: string;
+        }>;
+        transactions: (limit?: number) => Promise<Array<{
+            id: string;
+            operation: string;
+            credits: number;
+            timestamp: string;
+            description: string;
+        }>>;
+        refresh: () => Promise<{
+            success: boolean;
+        }>;
+        purchase: (amount: number) => Promise<{
+            success: boolean;
+            creditsAdded?: number;
+            newBalance?: number;
+            error?: string;
+        }>;
+        getPaymentMethod: () => Promise<{
+            hasMethod: boolean;
+            card?: {
+                brand: string;
+                last4: string;
+                expMonth: number;
+                expYear: number;
+                name: string;
+            };
+        }>;
+        savePaymentMethod: (data: Record<string, string>) => Promise<{
+            success: boolean;
+            card?: {
+                brand: string;
+                last4: string;
+                expMonth: number;
+                expYear: number;
+                name: string;
+            };
+            error?: string;
+        }>;
+    };
+    settings: {
+        get: () => Promise<{
+            theme: 'dark' | 'light' | 'system';
+            startOnBoot: boolean;
+            minimizeToTray: boolean;
+            checkUpdatesAutomatically: boolean;
+            showNotifications: boolean;
+            defaultApp: string | null;
+            language: string;
+            analytics: boolean;
+        }>;
+        getValue: (key: string) => Promise<unknown>;
+        set: (updates: Record<string, unknown>) => Promise<Record<string, unknown>>;
+        reset: () => Promise<Record<string, unknown>>;
+    };
+    bgRemoval?: {
+        checkAvailable: () => Promise<{
+            available: boolean;
+            error: string | null;
+        }>;
+        checkModel: () => Promise<{
+            exists: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        initModel: (useGpu?: boolean) => Promise<{
+            loaded: boolean;
+            modelPath: string | null;
+            usingGpu: boolean;
+            error: string | null;
+        }>;
+        getStatus: () => Promise<{
+            loaded: boolean;
+            modelPath: string | null;
+            usingGpu: boolean;
+            error: string | null;
+        }>;
+        processFile: (inputPath: string, outputPath?: string) => Promise<{
+            success: boolean;
+            outputPath: string | null;
+            error: string | null;
+            processingTimeMs: number | null;
+        }>;
+        processBuffer: (base64Data: string) => Promise<{
+            success: boolean;
+            data: string | null;
+            error: string | null;
+        }>;
+        downloadModel: () => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        onDownloadProgress: (callback: (progress: {
+            downloaded: number;
+            total: number;
+            progress: number;
+        }) => void) => void;
+        offDownloadProgress: () => void;
+    };
+    llm: {
+        chat: (params: {
+            requestId: string;
+            model: string;
+            messages: Array<{
+                role: string;
+                content: string;
+            }>;
+            temperature?: number;
+            max_tokens?: number;
+            system?: string;
+            think?: boolean;
+            enableTools?: boolean;
+        }) => Promise<{
+            success: boolean;
+            requestId: string;
+        }>;
+        chatOnce: (params: {
+            model: string;
+            messages: Array<{
+                role: string;
+                content: string;
+            }>;
+            temperature?: number;
+            max_tokens?: number;
+            system?: string;
+            think?: boolean;
+        }) => Promise<{
+            success: boolean;
+            content: string;
+            thinking: string;
+            error: string | null;
+        }>;
+        localWarmup: (params: {
+            model: string;
+            timeoutMs?: number;
+        }) => Promise<{
+            success: boolean;
+            loadedModel: string | null;
+            error: string | null;
+        }>;
+        localRuntimeStart: () => Promise<{
+            success: boolean;
+            runtime: {
+                available: boolean;
+                managed: boolean;
+                loadedModelId: string | null;
+                loadedModelName: string | null;
+                error: string | null;
+            };
+            error: string | null;
+        }>;
+        localRuntimeStop: () => Promise<{
+            success: boolean;
+            runtime: {
+                available: boolean;
+                managed: boolean;
+                loadedModelId: string | null;
+                loadedModelName: string | null;
+                error: string | null;
+            };
+            error: string | null;
+        }>;
+        localModelInstall: (params: {
+            modelId: string;
+            repo?: string;
+            file?: string;
+            quantization?: string;
+            source?: 'r2' | 'huggingface';
+            downloadUrl?: string;
+            artifactKey?: string;
+            filename?: string;
+            sizeBytes?: number;
+            sha256?: string;
+        }) => Promise<{
+            success: boolean;
+            installedPath?: string;
+            error?: string;
+        }>;
+        localModelRemove: (params: {
+            modelId: string;
+            path: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        abort: (requestId: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        models: () => Promise<{
+            success: boolean;
+            models: Array<{
+                id: string;
+                object: string;
+                availability?: 'available' | 'degraded' | 'unavailable';
+                availabilityReason?: string | null;
+                source?: 'api' | 'platform-auth' | 'public-fallback' | 'static-fallback';
+            }>;
+            error: string | null;
+        }>;
+        localModelCatalog: () => Promise<{
+            success: boolean;
+            source: 'platform' | 'fallback';
+            catalogVersion: string | null;
+            updatedAt: string | null;
+            models: Array<{
+                id: string;
+                name: string;
+                provider: string;
+                category: 'all' | 'llm' | 'image' | 'video' | 'audio' | 'upscale' | 'embedding';
+                description: string;
+                size: string;
+                sizeBytes?: number | null;
+                parameters?: string | null;
+                tags: string[];
+                license?: string | null;
+                runtime?: string | null;
+                installable: boolean;
+                installSpec?: {
+                    source?: 'r2' | 'huggingface';
+                    repo?: string;
+                    file?: string;
+                    quantization?: string;
+                    downloadUrl?: string | null;
+                    artifactKey?: string | null;
+                    filename?: string | null;
+                    sizeBytes?: number | null;
+                    sha256?: string | null;
+                    expectedLocalIds: string[];
+                } | null;
+                unavailableReason?: string | null;
+            }>;
+            error: string | null;
+        }>;
+        localModels: () => Promise<{
+            success: boolean;
+            models: Array<{
+                id: string;
+                name: string;
+                tag: string;
+                size: number;
+                parameterSize: string | null;
+                family: string | null;
+                path: string;
+                loaded: boolean;
+            }>;
+            runtime: {
+                available: boolean;
+                managed: boolean;
+                loadedModelId: string | null;
+                loadedModelName: string | null;
+                error: string | null;
+            };
+            error: string | null;
+        }>;
+        onLocalModelInstallProgress: (callback: (data: {
+            modelId: string;
+            phase: 'starting' | 'downloading' | 'complete' | 'error';
+            progress: number;
+            message: string;
+            installedPath?: string;
+        }) => void) => void;
+        offLocalModelInstallProgress: () => void;
+        onChatChunk: (callback: (data: {
+            requestId: string;
+            content: string;
+            thinking: string;
+            done: boolean;
+        }) => void) => void;
+        offChatChunk: () => void;
+        onChatError: (callback: (data: {
+            requestId: string;
+            error: string;
+        }) => void) => void;
+        offChatError: () => void;
+        onToolCall: (callback: (data: {
+            requestId: string;
+            status: 'start' | 'end';
+            toolName: string;
+            toolParams?: Record<string, unknown>;
+            result?: string;
+            success?: boolean;
+        }) => void) => void;
+        offToolCall: () => void;
+    };
+    agent: {
+        run: (params: {
+            requestId: string;
+            conversationId?: string;
+            sdkSessionId?: string;
+            previousRunId?: string;
+            subagentRunId?: string;
+            workspaceId?: string;
+            teamId?: string;
+            agentId?: string;
+            providerId?: string;
+            providerKind?: 'sdk-native' | 'xeno-cloud';
+            mode?: 'chat' | 'development';
+            model: string;
+            messages: Array<{
+                role: string;
+                content: string;
+            }>;
+            systemPrompt?: string;
+            maxIterations?: number;
+            enableThinking?: boolean;
+            reasoningOptionId?: string;
+            capabilities?: {
+                terminal?: boolean;
+                browser?: boolean;
+                fileRead?: boolean;
+                fileWrite?: boolean;
+                appLaunch?: boolean;
+                webSearch?: boolean;
+                codeExecution?: boolean;
+                imageGeneration?: boolean;
+                dataAnalysis?: boolean;
+            };
+            permissionProfile?: 'standard' | 'read-only' | 'edit-with-approval' | 'trusted-workspace' | 'plan';
+            allowedDirectories?: string[];
+            approvalRules?: Array<Record<string, unknown>>;
+            contextCompaction?: AgentContextCompactionMetrics;
+        }) => Promise<{
+            success: boolean;
+            requestId?: string;
+            error?: string;
+            hostBinding?: import('@xenosystem/agent-interface-contract').AgentSessionHostBindingV1;
+            activeLane?: import('@xenosystem/agent-interface-contract').ProviderLaneProjectionV1;
+            lanes?: import('@xenosystem/agent-interface-contract').ProviderLaneProjectionV1[];
+        }>;
+        cancel: (requestId: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        onTextChunk: (callback: (data: {
+            requestId: string;
+            text: string;
+        }) => void) => void;
+        offTextChunk: () => void;
+        onToolStart: (callback: (data: {
+            requestId: string;
+            toolCallId?: string;
+            name: string;
+            input: unknown;
+            startedAt?: number;
+        }) => void) => void;
+        offToolStart: () => void;
+        onToolEnd: (callback: (data: {
+            requestId: string;
+            toolCallId?: string;
+            name: string;
+            result: string;
+            success: boolean;
+            startedAt?: number;
+            endedAt?: number;
+            durationMs?: number;
+            diff?: ConversationEditorDiff;
+        }) => void) => void;
+        offToolEnd: () => void;
+        onRuntimeEvent: (callback: (data: {
+            requestId: string;
+            event: Record<string, unknown>;
+        }) => void) => void;
+        offRuntimeEvent: () => void;
+        onTaskEvent: (callback: (data: {
+            requestId: string;
+            action: 'create' | 'update' | 'clear';
+            task?: {
+                id: string;
+                text: string;
+                detail?: string;
+                status?: 'pending' | 'in_progress' | 'done' | 'blocked';
+                order?: number;
+            };
+            taskId?: string;
+            patch?: {
+                text?: string;
+                detail?: string;
+                status?: 'pending' | 'in_progress' | 'done' | 'blocked';
+                order?: number;
+            };
+        }) => void) => void;
+        offTaskEvent: () => void;
+        onDone: (callback: (data: {
+            requestId: string;
+        }) => void) => void;
+        offDone: () => void;
+        onError: (callback: (data: {
+            requestId: string;
+            error: string;
+            context?: string;
+        }) => void) => void;
+        offError: () => void;
+        onPermissionRequest: (callback: (data: {
+            requestId: string;
+            permissionId: string;
+            toolName: string;
+            path: string;
+            directory: string;
+            browserOrigin?: string;
+            allowAlwaysOptionId?: string;
+            rejectAlwaysOptionId?: string;
+        }) => void) => void;
+        offPermissionRequest: () => void;
+        onAskUserRequest: (callback: (data: {
+            requestId: string;
+            askUserId: string;
+            question: string;
+            options?: string[];
+            context?: string;
+        }) => void) => void;
+        offAskUserRequest: () => void;
+        onChooseDirectoryRequest: (callback: (data: {
+            requestId: string;
+            chooseDirectoryId: string;
+            title?: string;
+        }) => void) => void;
+        offChooseDirectoryRequest: () => void;
+        subscribeChooseDirectoryRequested: (callback: (data: unknown) => void) => string;
+        unsubscribeChooseDirectoryRequested: (subscriptionId: string) => boolean;
+        onWorkspacePlacementRequest: (callback: (data: {
+            requestId: string;
+            workspacePlacementId: string;
+            directory: string;
+            title?: string;
+        }) => void) => void;
+        offWorkspacePlacementRequest: () => void;
+        subscribeWorkspacePlacementRequested: (callback: (data: unknown) => void) => string;
+        unsubscribeWorkspacePlacementRequested: (subscriptionId: string) => boolean;
+        grantAccess: (params: {
+            permissionId: string;
+            directory: string;
+            selectedOptionId?: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        denyAccess: (params: {
+            permissionId: string;
+            selectedOptionId?: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        steerTurn: (params: {
+            conversationId: string;
+            requestId: string;
+            instruction: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        resumeTurn: (params: {
+            conversationId: string;
+            requestId: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        /**
+         * What is waiting to run for this conversation, and how to take it
+         * back out.
+         *
+         * 🔴 These exist because the host's queue had no surface at all.
+         * Typing during a turn the agent cannot take mid-flight becomes a
+         * queued instruction, and until now a person was told that had
+         * happened with no way to see it or undo it.
+         */
+        /**
+         * Messages withheld from a run pending a human (coordination §6).
+         *
+         * 🔴 `available: false` means this host does not coordinate at all,
+         * which is a different fact from a run with nothing held. A surface
+         * that showed an empty list for both would wait for approvals that
+         * can never arrive.
+         */
+        listHeldMessages: (params: {
+            runId: string;
+        }) => Promise<{
+            available: boolean;
+            runId: string;
+            held: Array<{
+                id: string;
+                fromRunId: string;
+                text: string;
+                sentAt: number;
+            }>;
+            reason?: string;
+        }>;
+        releaseHeldMessage: (params: {
+            runId: string;
+            messageId: string;
+        }) => Promise<{
+            status: 'delivered' | 'expired' | 'refused' | 'held';
+            messageId: string;
+            reason?: string;
+        }>;
+        /**
+         * Pins or clears a run's inbound-message policy (§6).
+         *
+         * `policy: null` returns the run to the derived default and is NOT the
+         * same as 'accept', which pins the permissive answer.
+         */
+        setInboundPolicy: (params: {
+            runId: string;
+            policy: 'accept' | 'hold' | 'refuse' | null;
+        }) => Promise<{
+            ok: boolean;
+            explicit?: 'accept' | 'hold' | 'refuse';
+            reason?: string;
+        }>;
+        listQueuedInstructions: (params: {
+            conversationId: string;
+        }) => Promise<{
+            conversationId: string;
+            /**
+             * 🔴 `queuedByYou`, never the raw instance id.
+             *
+             * The contract carries `queuedByInstanceId` "for provenance in the
+             * timeline" and no surface read it. Rendering an opaque id would be
+             * noise; the useful question is whether ANOTHER surface queued this,
+             * which matters before you drop it — the same reason the sessions
+             * board surfaces `othersWatching`.
+             *
+             * Derived in the bridge because the bridge already holds this
+             * surface's identity and already answers exactly this question when
+             * routing PTY events. A panel doing its own comparison would be a
+             * second copy of that rule.
+             */
+            queue: Array<{
+                id: string;
+                instruction: string;
+                queuedAt: string;
+                queuedByYou: boolean;
+            }>;
+            turnActive: boolean;
+        }>;
+        dropQueuedInstruction: (params: {
+            conversationId: string;
+            instructionId?: string;
+        }) => Promise<{
+            success: boolean;
+            safeError?: string;
+        }>;
+        listPermissionRules: () => Promise<{
+            success: boolean;
+            rules: Array<{
+                id: string;
+                decision: 'allow' | 'deny';
+                toolKind?: string;
+                pathPrefix?: string;
+                createdAt?: number;
+            }>;
+            error?: string;
+        }>;
+        revokePermissionRule: (params: {
+            ruleId: string;
+        }) => Promise<{
+            success: boolean;
+            revoked: boolean;
+            error?: string;
+        }>;
+        answerAskUser: (params: {
+            askUserId: string;
+            answer: string;
+            selectedOption?: string;
+            cancelled?: boolean;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        answerChooseDirectory: (params: {
+            requestId?: string;
+            chooseDirectoryId: string;
+            path?: string;
+            cancelled?: boolean;
+            error?: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        answerWorkspacePlacement: (params: {
+            requestId?: string;
+            workspacePlacementId: string;
+            directory?: string;
+            choice?: 'inbox' | 'reuse' | 'create';
+            workspaceName?: string;
+            result?: string;
+            cancelled?: boolean;
+            error?: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        listSdkSessions: (params?: {
+            role?: string;
+            workingDirectory?: string;
+            limit?: number;
+        }) => Promise<{
+            success: boolean;
+            sessions?: unknown[];
+            error?: string;
+        }>;
+        showSdkSession: (params: {
+            sessionId: string;
+        }) => Promise<{
+            success: boolean;
+            session?: unknown;
+            sessionDir?: string;
+            checkpoints?: unknown[];
+            error?: string;
+        }>;
+        attachSdkSession: (params: {
+            conversationId: string;
+            sessionId: string;
+        }) => Promise<{
+            success: boolean;
+            session?: unknown;
+            sessionDir?: string;
+            sessionHistoryPath?: string;
+            coordinationSessionId?: string;
+            checkpoints?: unknown[];
+            error?: string;
+        }>;
+        detachSdkSession: (params: {
+            conversationId: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        deleteSdkSession: (params: {
+            sessionId: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        cleanSdkSessions: (params: {
+            workingDirectory: string;
+            excludeSessionIds?: string[];
+        }) => Promise<{
+            success: boolean;
+            result?: unknown;
+            error?: string;
+        }>;
+        listSdkCheckpoints: (params: {
+            sessionId: string;
+        }) => Promise<{
+            success: boolean;
+            checkpoints?: unknown[];
+            error?: string;
+        }>;
+        restoreSdkCheckpoint: (params: {
+            sessionId: string;
+            checkpointId: string;
+            conversationId?: string;
+        }) => Promise<{
+            success: boolean;
+            restored?: unknown;
+            pendingRuntimeRestore?: boolean;
+            error?: string;
+        }>;
+        deleteSdkCheckpoint: (params: {
+            sessionId: string;
+            checkpointId: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        readSdkTaskOutput: (params: {
+            taskId: string;
+            offset?: number;
+        }) => Promise<{
+            success: boolean;
+            output?: string;
+            error?: string;
+            command?: string;
+            status?: 'running' | 'completed' | 'failed' | 'stopped' | 'unknown';
+            exitCode?: number | null;
+            totalSize?: number;
+        }>;
+        stopSdkTask: (params: {
+            taskId: string;
+        }) => Promise<{
+            success: boolean;
+            output?: string;
+            error?: string;
+            command?: string;
+            status?: 'running' | 'completed' | 'failed' | 'stopped' | 'unknown';
+            exitCode?: number | null;
+            totalSize?: number;
+        }>;
+    };
+    agentsCloud?: {
+        status: () => Promise<{
+            success: boolean;
+            authenticated: boolean;
+            ok?: boolean;
+            capabilities?: string[];
+            version?: string;
+            error?: string;
+            code?: string;
+        }>;
+        createRun: (params: {
+            prompt: string;
+            model?: string;
+            title?: string;
+            previousRunId?: string;
+            workspace?: string;
+            budget?: {
+                maxCredits?: number;
+            };
+        }) => Promise<{
+            success: boolean;
+            run?: import('@xenosystem/agent-interface-contract').AgentRunRecord;
+            error?: string;
+            code?: string;
+            status?: number;
+        }>;
+        listRuns: (params?: {
+            limit?: number;
+        }) => Promise<{
+            success: boolean;
+            runs?: import('@xenosystem/agent-interface-contract').RunListItem[];
+            error?: string;
+            code?: string;
+        }>;
+        getRun: (params: {
+            runId: string;
+        }) => Promise<{
+            success: boolean;
+            run?: import('@xenosystem/agent-interface-contract').AgentRunRecord;
+            error?: string;
+            code?: string;
+        }>;
+        attach: (params: {
+            requestId: string;
+            runId: string;
+        }) => Promise<{
+            success: boolean;
+            requestId?: string;
+            runId?: string;
+            error?: string;
+            code?: string;
+        }>;
+        stop: (params: {
+            requestId?: string;
+            runId?: string;
+        }) => Promise<{
+            success: boolean;
+            run?: import('@xenosystem/agent-interface-contract').AgentRunRecord;
+            error?: string;
+            code?: string;
+        }>;
+        onRunStatus: (callback: (data: {
+            requestId: string;
+            runId: string;
+            status?: string;
+            statusReason?: string | null;
+            creditsHeld?: number | null;
+            creditsSettled?: number | null;
+            url?: string;
+        }) => void) => void;
+        offRunStatus: () => void;
+    };
+    workspace: {
+        lifecycle?: (input: Omit<import('@xenosystem/agent-interface-contract').AgentWorkspaceLifecycleRequest, 'command'>) => Promise<import('@xenosystem/agent-interface-contract').AgentWorkspaceLifecycleResult>;
+        schedule?: (input: import('@xenosystem/agent-interface-contract').AgentScheduleRequest) => Promise<import('@xenosystem/agent-interface-contract').AgentScheduleResult>;
+        environment?: (input: import('@xenosystem/agent-interface-contract').AgentEnvironmentRequest) => Promise<import('@xenosystem/agent-interface-contract').AgentEnvironmentResult>;
+        pickDirectory: () => Promise<{
+            success: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        pickExecutable: () => Promise<{
+            success: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        listDirectory: (params: {
+            dirPath: string;
+            allowedDirs: string[];
+        }) => Promise<{
+            success: boolean;
+            entries: Array<{
+                name: string;
+                path: string;
+                size: number;
+                modified: string;
+                type: 'file' | 'directory';
+                extension: string;
+            }>;
+            error: string | null;
+        }>;
+        readFile: (params: {
+            path: string;
+            allowedDirs: string[];
+            conversationId?: string;
+        }) => Promise<{
+            success: boolean;
+            path: string | null;
+            content: string;
+            bytes: number;
+            error: string | null;
+        }>;
+        getFileOpenOptions: (params: {
+            path: string;
+            allowedDirs: string[];
+            conversationId?: string;
+        }) => Promise<{
+            success: boolean;
+            path: string | null;
+            defaultApp: {
+                name: string;
+            } | null;
+            options: Array<{
+                target: 'cursor' | 'antigravity' | 'default' | 'explorer' | 'terminal' | 'git-bash' | 'wsl';
+                label: string;
+            }>;
+            revealLabel: string;
+            error: string | null;
+        }>;
+        openFileWith: (params: {
+            path: string;
+            target: 'cursor' | 'antigravity' | 'default' | 'explorer' | 'terminal' | 'git-bash' | 'wsl';
+            allowedDirs: string[];
+            conversationId?: string;
+        }) => Promise<{
+            success: boolean;
+            path: string | null;
+            target: 'cursor' | 'antigravity' | 'default' | 'explorer' | 'terminal' | 'git-bash' | 'wsl' | null;
+            error: string | null;
+        }>;
+        runCommand: (params: {
+            conversationId?: string;
+            workspaceId?: string;
+            teamId?: string;
+            agentId?: string;
+            command: string;
+            cwd?: string;
+            allowedDirs: string[];
+            timeoutMs?: number;
+        }) => Promise<{
+            success: boolean;
+            stdout: string;
+            stderr: string;
+            exitCode: number | null;
+            cwd: string | null;
+            error: string | null;
+            /**
+             * Output hit the ceiling and was trimmed.
+             *
+             * OPTIONAL here while REQUIRED on the contract, and the asymmetry is
+             * deliberate: the contract describes what THIS host produces, and it
+             * always knows. This describes what a preload happens to deliver,
+             * which may be an older host that predates the field. Absent
+             * therefore means "this host cannot say" — which is exactly why it
+             * must not be defaulted to `false` on the way through, since that
+             * would assert output was complete on no evidence.
+             */
+            truncated?: boolean;
+        }>;
+        terminalStart: (params: {
+            conversationId?: string;
+            command: string;
+            cwd?: string;
+            allowedDirs: string[];
+            timeoutMs?: number;
+        }) => Promise<{
+            success: boolean;
+            terminalId: string | null;
+            cwd: string | null;
+            error: string | null;
+        }>;
+        terminalStop: (params: {
+            terminalId: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        ptyStart: (params: {
+            conversationId?: string;
+            cwd?: string;
+            allowedDirs: string[];
+            cols?: number;
+            rows?: number;
+            profile?: import('@xenosystem/agent-interface-contract').ProviderSessionPtyProfile;
+        }) => Promise<{
+            success: boolean;
+            terminalId: string | null;
+            cwd: string | null;
+            code?: import('@xenosystem/agent-interface-contract').AgentCockpitErrorCode;
+            error: string | null;
+        }>;
+        xenoTuiAttach?: (params: {
+            conversationId: string;
+            workspaceMode: 'agent' | 'chat';
+            workingDirectory?: string;
+            workspaceId?: string;
+            providerKind: 'sdk-native' | 'xeno-cloud' | 'acp-provider';
+            providerId?: string;
+            acpAgentConfigId?: string;
+            model?: string;
+            cols?: number;
+            rows?: number;
+        }) => Promise<import('@xenosystem/agent-interface-contract').AgentXenoTuiAttachResult & {
+            lanes?: import('@xenosystem/agent-interface-contract').ProviderLaneProjectionV1[];
+        }>;
+        providerLaneSelect?: (params: {
+            conversationId: string;
+            workspaceMode: 'agent' | 'chat';
+            workingDirectory?: string;
+            workspaceId?: string;
+            providerKind: 'sdk-native' | 'xeno-cloud' | 'acp-provider';
+            providerId?: string;
+            acpAgentConfigId?: string;
+            model?: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+            hostBinding?: import('@xenosystem/agent-interface-contract').AgentSessionHostBindingV1;
+            activeLane?: import('@xenosystem/agent-interface-contract').ProviderLaneProjectionV1;
+            lanes?: import('@xenosystem/agent-interface-contract').ProviderLaneProjectionV1[];
+        }>;
+        providerNativeAttach?: (params: {
+            conversationId: string;
+            laneId: string;
+            expectedLaneRevision: number;
+            workspaceTrust?: 'standard' | 'trusted';
+            executionPolicy?: import('@xenosystem/agent-interface-contract').AgentNativeExecutionPolicy;
+            cols?: number;
+            rows?: number;
+        }) => Promise<import('@xenosystem/agent-interface-contract').AgentProviderNativeAttachResult>;
+        conversationResume?: (params: {
+            conversationId: string;
+            expectedWorkspaceEpochId?: string;
+        }) => Promise<import('@xenosystem/agent-interface-contract').AgentConversationResumeResult>;
+        providerLanesList?: (params: {
+            conversationId: string;
+            includeHistorical?: boolean;
+        }) => Promise<import('@xenosystem/agent-interface-contract').AgentProviderLaneListResult>;
+        providerNativeDetach?: (params: {
+            conversationId: string;
+            laneId: string;
+            terminalId?: string;
+        }) => Promise<import('@xenosystem/agent-interface-contract').AgentProviderNativeDetachResult>;
+        providerNativeReattach?: (params: {
+            conversationId: string;
+            laneId: string;
+            terminalId: string;
+            cols?: number;
+            rows?: number;
+        }) => Promise<import('@xenosystem/agent-interface-contract').AgentProviderNativeReattachResult>;
+        providerNativeStop?: (params: {
+            conversationId: string;
+            laneId: string;
+            terminalId?: string;
+            force?: boolean;
+            reason?: string;
+        }) => Promise<import('@xenosystem/agent-interface-contract').AgentProviderNativeStopResult>;
+        providerReconcile?: (params: {
+            conversationId: string;
+            laneId: string;
+            expectedLaneRevision: number;
+            acknowledgePartialContext?: boolean;
+        }) => Promise<import('@xenosystem/agent-interface-contract').AgentProviderReconcileResult>;
+        ptySnapshot: (params: {
+            terminalId: string;
+        }) => Promise<{
+            success: boolean;
+            exists: boolean;
+            terminalId: string;
+            cwd: string | null;
+            output: string;
+            error: string | null;
+        }>;
+        ptyInput: (params: {
+            terminalId: string;
+            data: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        ptyResize: (params: {
+            terminalId: string;
+            cols: number;
+            rows: number;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        ptyClear: (params: {
+            terminalId: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        ptyStop: (params: {
+            terminalId: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        browserRegister: (params: {
+            browserTabId: string;
+            label?: string;
+            webContentsId: number;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        browserUnregister: (params: {
+            browserTabId: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        browserList: () => Promise<{
+            success: boolean;
+            tabs: Array<{
+                browserTabId: string;
+                label: string;
+                webContentsId: number;
+                url: string;
+                title: string;
+                isLoading: boolean;
+                canGoBack: boolean;
+                canGoForward: boolean;
+            }>;
+            error: string | null;
+        }>;
+        browserSnapshot: (params: {
+            browserTabId: string;
+            maxTextChars?: number;
+            maxElements?: number;
+        }) => Promise<{
+            success: boolean;
+            snapshot: unknown | null;
+            error: string | null;
+        }>;
+        browserGoto: (params: {
+            browserTabId: string;
+            url: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        browserClick: (params: {
+            browserTabId: string;
+            selector: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        browserType: (params: {
+            browserTabId: string;
+            selector: string;
+            text: string;
+            clear?: boolean;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        browserKey: (params: {
+            browserTabId: string;
+            key: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        onPtyData: (callback: (data: {
+            terminalId: string;
+            data: string;
+        }) => void) => void;
+        offPtyData: () => void;
+        onPtyExit: (callback: (data: {
+            terminalId: string;
+            exitCode: number;
+            signal?: number;
+        }) => void) => void;
+        offPtyExit: () => void;
+        onTerminalData: (callback: (data: {
+            terminalId: string;
+            stream: 'stdout' | 'stderr';
+            chunk: string;
+        }) => void) => void;
+        offTerminalData: () => void;
+        onTerminalExit: (callback: (data: {
+            terminalId: string;
+            command: string;
+            cwd: string;
+            success: boolean;
+            exitCode: number | null;
+            error: string | null;
+        }) => void) => void;
+        offTerminalExit: () => void;
+        writeFile: (params: {
+            conversationId?: string;
+            workspaceId?: string;
+            teamId?: string;
+            agentId?: string;
+            path: string;
+            content: string;
+            expectedContent?: string | null;
+            allowedDirs: string[];
+        }) => Promise<{
+            success: boolean;
+            path: string | null;
+            bytes: number;
+            error: string | null;
+            outcome?: 'committed' | 'not-committed' | 'uncertain';
+            sha256?: string;
+            recoveryPaths?: string[];
+        }>;
+        openApp: (params: {
+            appPath: string;
+            args?: string[];
+            allowedApps: string[];
+        }) => Promise<{
+            success: boolean;
+            appPath: string | null;
+            error: string | null;
+        }>;
+    };
+    sandbox?: {
+        execute: (params: {
+            conversationId: string;
+            language: 'python' | 'javascript';
+            code: string;
+            timeoutMs?: number;
+        }) => Promise<{
+            success: boolean;
+            stdout: string;
+            stderr: string;
+            exitCode: number | null;
+            durationMs: number;
+            files: string[];
+            error: string | null;
+        }>;
+        abort: (params: {
+            conversationId: string;
+        }) => Promise<{
+            success: boolean;
+        }>;
+        cleanup: (params: {
+            conversationId: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        detectRuntimes: () => Promise<{
+            python: {
+                available: boolean;
+                version: string | null;
+                command: string | null;
+            };
+            node: {
+                available: boolean;
+                version: string | null;
+            };
+        }>;
+    };
+    convert?: {
+        checkAvailable: (params?: ScopedIpcParams) => Promise<{
+            available: boolean;
+            error: string | null;
+        }>;
+        supportedFormats: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            error: string | null;
+            formats: {
+                imageInput: string[];
+                imageOutput: string[];
+                audioInput: string[];
+                audioOutput: string[];
+            } | null;
+        }>;
+        inspectFile: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            error: string | null;
+            info: {
+                fileType: string;
+                format: string;
+                fileSize: number;
+                fileName: string;
+                width?: number;
+                height?: number;
+                sampleRate?: number;
+                channels?: number;
+                durationSecs?: number;
+                bitrateKbps?: number;
+                codec?: string;
+                bitsPerSample?: number;
+                title?: string;
+                artist?: string;
+                album?: string;
+            } | null;
+        }>;
+        writeTempImage: (dataUrl: string | ({
+            dataUrl: string;
+        } & ScopedIpcParams)) => Promise<{
+            success: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        getPathForFile: (file: File) => string;
+        convert: (inputPath: string | ({
+            inputPath: string;
+            outputPath: string;
+            options?: ConvertOptions;
+        } & ScopedIpcParams), outputPath?: string, options?: ConvertOptions) => Promise<{
+            success: boolean;
+            outputPath?: string;
+            error?: string;
+            processingTimeMs?: number;
+        }>;
+        createVideoPreview: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            outputPath: string | null;
+            error: string | null;
+            reused?: boolean;
+            processingTimeMs?: number;
+        }>;
+        pickFile: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            path: string | null;
+        }>;
+        saveFile: (format: string | ({
+            format: string;
+            defaultName?: string;
+        } & ScopedIpcParams), defaultName?: string) => Promise<{
+            success: boolean;
+            path: string | null;
+            error?: string;
+        }>;
+        readThumbnail: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            dataUrl: string | null;
+            error?: string;
+        }>;
+    };
+    compressor?: {
+        pickFiles: () => Promise<{
+            success: boolean;
+            paths: string[];
+            error: string | null;
+        }>;
+        pickOutputDirectory: (defaultPath?: string) => Promise<{
+            success: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        inspectFiles: (inputPaths: string[]) => Promise<{
+            success: boolean;
+            files: Array<{
+                path: string;
+                name: string;
+                kind: 'image' | 'pdf' | 'unsupported';
+                formatLabel: string;
+                extension: string;
+                bytes: number;
+                supported: boolean;
+                reason: string | null;
+                width?: number;
+                height?: number;
+                pageCount?: number;
+            }>;
+            error: string | null;
+        }>;
+        compress: (params: {
+            requestId: string;
+            inputPaths: string[];
+            outputDirectory: string;
+            profile: 'light' | 'balanced' | 'strong';
+            imageFormat: 'auto' | 'same' | 'webp' | 'jpeg' | 'png';
+            skipIfLarger?: boolean;
+            stripPdfMetadata?: boolean;
+        }) => Promise<{
+            success: boolean;
+            results: Array<{
+                path: string;
+                name: string;
+                kind: 'image' | 'pdf' | 'unsupported';
+                status: 'compressed' | 'skipped' | 'failed';
+                inputBytes: number;
+                outputBytes?: number;
+                bytesSaved: number;
+                percentSaved: number;
+                outputPath?: string;
+                outputFormat?: string;
+                message: string;
+                processingTimeMs?: number;
+            }>;
+            summary: {
+                processed: number;
+                compressed: number;
+                skipped: number;
+                failed: number;
+                totalOriginalBytes: number;
+                totalEffectiveBytes: number;
+                totalBytesSaved: number;
+                percentSaved: number;
+                outputDirectory: string;
+                firstOutputPath?: string;
+            } | null;
+            error: string | null;
+        }>;
+        showInFolder: (targetPath: string) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        onProgress: (callback: (data: {
+            requestId: string;
+            current: number;
+            total: number;
+            path: string;
+            name: string;
+            stage: 'start' | 'end';
+            result?: {
+                path: string;
+                name: string;
+                kind: 'image' | 'pdf' | 'unsupported';
+                status: 'compressed' | 'skipped' | 'failed';
+                inputBytes: number;
+                outputBytes?: number;
+                bytesSaved: number;
+                percentSaved: number;
+                outputPath?: string;
+                outputFormat?: string;
+                message: string;
+                processingTimeMs?: number;
+            };
+        }) => void) => void;
+        offProgress: () => void;
+    };
+    pdfMerge?: {
+        pickFiles: () => Promise<{
+            success: boolean;
+            paths: string[];
+            error: string | null;
+        }>;
+        saveFile: (defaultName?: string) => Promise<{
+            success: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        readFile: (filePath: string) => Promise<{
+            success: boolean;
+            sourceType: 'pdf' | 'image' | null;
+            pdfBase64: string | null;
+            imageDataUrl: string | null;
+            error: string | null;
+        }>;
+        preview: (inputPaths: string[]) => Promise<{
+            success: boolean;
+            pdfBase64: string | null;
+            pageCount: number;
+            error: string | null;
+        }>;
+        merge: (params: {
+            inputPaths: string[];
+            outputPath: string;
+        }) => Promise<{
+            success: boolean;
+            outputPath?: string;
+            mergedCount?: number;
+            pageCount?: number;
+            error?: string;
+        }>;
+        showInFolder: (filePath: string) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+    };
+    latex?: {
+        checkInstalled: () => Promise<{
+            installed: boolean;
+            engine: string | null;
+            version: string | null;
+            installInstructions: string | null;
+        }>;
+        compile: (texContent: string, engine?: string) => Promise<{
+            success: boolean;
+            pdfPath: string | null;
+            pdfBase64: string | null;
+            log: string;
+        }>;
+        openFile: () => Promise<{
+            success: boolean;
+            content: string | null;
+            filePath: string | null;
+            error: string | null;
+        }>;
+        savePdf: (pdfPath: string) => Promise<{
+            success: boolean;
+            savedPath?: string;
+            error: string | null;
+        }>;
+        saveTexFile: (content: string, currentPath?: string) => Promise<{
+            success: boolean;
+            filePath: string | null;
+            error: string | null;
+        }>;
+        aifix: (texContent: string, compilationLog: string) => Promise<{
+            success: boolean;
+            fixedContent: string | null;
+            error: string | null;
+        }>;
+        install: () => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        onInstallProgress: (callback: (data: {
+            phase: string;
+            percent: number;
+        }) => void) => void;
+        offInstallProgress: () => void;
+    };
+    updater?: {
+        check: () => Promise<unknown>;
+        download: () => Promise<void>;
+        install: () => void;
+        getVersion: () => Promise<string>;
+        onUpdateAvailable: (cb: (info: {
+            version: string;
+            releaseNotes?: string;
+        }) => void) => void;
+        onUpToDate: (cb: () => void) => void;
+        onDownloadProgress: (cb: (progress: {
+            percent: number;
+            bytesPerSecond: number;
+            transferred: number;
+            total: number;
+        }) => void) => void;
+        onDownloaded: (cb: () => void) => void;
+        onError: (cb: (msg: string) => void) => void;
+        offAll: () => void;
+    };
+    chatStorage?: {
+        saveConversation: (conversation: unknown) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        loadConversations: () => Promise<{
+            success: boolean;
+            conversations: unknown[];
+            error?: string;
+        }>;
+        deleteConversation: (id: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+    };
+    workspaceStorage: {
+        save: (workspaces: unknown, expectedRevision?: string) => Promise<{
+            success: boolean;
+            revision?: string;
+            code?: 'WORKSPACE_CONFLICT' | 'WORKSPACE_REVISION_REQUIRED';
+            error?: string;
+        }>;
+        load: () => Promise<import('@xenosystem/agent-interface-contract').AgentWorkspaceStateLoadResult>;
+        onChanged: (callback: (data: {
+            source?: string;
+            action?: string;
+            revision?: string;
+        }) => void) => void | (() => void);
+        offChanged: () => void;
+    };
+    imageProjects?: {
+        listModels: () => Promise<{
+            success: boolean;
+            models: Array<{
+                id: string;
+                type: 'image' | 'video';
+                available: boolean;
+                reason?: string | null;
+                capabilities?: {
+                    maxCount?: number;
+                    supportedAspectRatios?: string[];
+                    supportedResolutions?: string[];
+                    maxResolution?: string;
+                    minDuration?: number;
+                    maxDuration?: number;
+                    supportsAudio?: boolean;
+                    supportsLastFrame?: boolean;
+                    requiresReferenceImage?: boolean;
+                    supportsReferenceImages?: boolean;
+                    maxReferenceImages?: number;
+                } | null;
+            }>;
+            error?: string | null;
+        }>;
+        list: () => Promise<any[]>;
+        create: (params: {
+            name: string;
+            modelPreference?: string;
+        }) => Promise<any>;
+        update: (params: {
+            id: string;
+            name?: string;
+            modelPreference?: string | null;
+            thumbnailUrl?: string | null;
+        }) => Promise<any>;
+        delete: (id: string) => Promise<any>;
+        getGenerations: (params: {
+            projectId: string;
+            limit?: number;
+            offset?: number;
+            favoritesOnly?: boolean;
+            lite?: boolean;
+            view?: 'gallery' | 'full' | 'lite';
+        }) => Promise<any>;
+        getGeneration: (params: {
+            projectId: string;
+            genId: string;
+        }) => Promise<any>;
+        saveGeneration: (params: {
+            projectId: string;
+            [key: string]: any;
+        }) => Promise<any>;
+        deleteGeneration: (params: {
+            projectId: string;
+            generationId: string;
+        }) => Promise<any>;
+        toggleFavorite: (params: {
+            projectId: string;
+            generationId: string;
+        }) => Promise<any>;
+        bulkDelete: (ids: string[]) => Promise<any>;
+        duplicate: (id: string) => Promise<any>;
+        generateImage: (params: Record<string, unknown>) => Promise<any>;
+        upscaleImage: (params: Record<string, unknown>) => Promise<any>;
+        generateVideo: (params: Record<string, unknown>) => Promise<any>;
+        upscaleVideo: (params: Record<string, unknown>) => Promise<any>;
+        readReferenceImage: (params: {
+            path: string;
+        } | string) => Promise<{
+            success: boolean;
+            path?: string;
+            name?: string;
+            mimeType?: string;
+            size?: number;
+            dataUrl?: string;
+            error?: string;
+        }>;
+        selectFolder: () => Promise<string | null>;
+        readFolderImages: (folderPath: string) => Promise<Array<{
+            name: string;
+            path: string;
+            size: number;
+            modified: number;
+        }>>;
+    };
+    agentContext?: {
+        get: () => Promise<{
+            success: boolean;
+            context: {
+                installedApps: string[];
+                userName: string | null;
+                provider: string;
+            } | null;
+            error?: string;
+        }>;
+    };
+    agentStorage: {
+        saveConversation: (conversation: unknown) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        loadConversations: () => Promise<{
+            success: boolean;
+            conversations: unknown[];
+            recoveredConversationIds?: string[];
+            corruptConversationFiles?: string[];
+            error?: string;
+        }>;
+        deleteConversation: (id: string) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+    };
+    agentSearch?: {
+        query: (params: unknown) => Promise<{
+            success: boolean;
+            results: unknown[];
+            total: number;
+            stats?: unknown;
+            error?: string;
+        }>;
+        hydrateResult: (params: {
+            id: string;
+        }) => Promise<{
+            success: boolean;
+            document?: unknown;
+            error?: string;
+        }>;
+        attachConversation: (params: unknown) => Promise<{
+            success: boolean;
+            attachment?: unknown;
+            error?: string;
+        }>;
+        detachConversation: (params: {
+            attachmentId: string;
+        }) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        listAttachments: (params: {
+            conversationId: string;
+        }) => Promise<{
+            success: boolean;
+            attachments: unknown[];
+            error?: string;
+        }>;
+        reindex: (params?: {
+            force?: boolean;
+            reason?: string;
+            cancelActive?: boolean;
+        }) => Promise<{
+            ready: boolean;
+            building: boolean;
+            error?: string;
+            stats: unknown;
+            health?: unknown;
+            lifecycle?: unknown;
+        }>;
+        cancelIndexing: (params?: {
+            jobId?: string;
+            reason?: string;
+        }) => Promise<{
+            ready: boolean;
+            building: boolean;
+            error?: string;
+            stats: unknown;
+            health?: unknown;
+            lifecycle?: unknown;
+        }>;
+        repair: (params?: {
+            force?: boolean;
+            cleanSnapshot?: boolean;
+        }) => Promise<{
+            success: boolean;
+            status: unknown;
+            repaired: unknown[];
+            durationMs: number;
+            error?: string;
+        }>;
+        health: (params?: unknown) => Promise<{
+            checkedAt: number;
+            healthy: boolean;
+            stale: boolean;
+            issues: unknown[];
+        }>;
+        profile: (params?: {
+            limit?: number;
+            slowOnly?: boolean;
+        }) => Promise<{
+            entries: unknown[];
+            slowQueries: unknown[];
+            averageQueryMs: number | null;
+            p95QueryMs: number | null;
+            failedQueryCount?: number;
+            health?: string;
+        }>;
+        watcherStatus: (params?: unknown) => Promise<{
+            success: boolean;
+            status?: unknown;
+            error?: string;
+        }>;
+        lifecycleStatus: (params?: unknown) => Promise<{
+            success: boolean;
+            status?: unknown;
+            error?: string;
+        }>;
+        status: () => Promise<{
+            ready: boolean;
+            building: boolean;
+            error?: string;
+            stats: unknown;
+            health?: unknown;
+            lifecycle?: unknown;
+        }>;
+    };
+    codeIndex?: {
+        indexWorkspace: (params: unknown) => Promise<{
+            success: boolean;
+            snapshot?: unknown;
+            stats?: unknown;
+            error?: string;
+        }>;
+        watch: (params: unknown) => Promise<{
+            success: boolean;
+            snapshot?: unknown;
+            stats?: unknown;
+            error?: string;
+        }>;
+        searchFiles: (params: unknown) => Promise<{
+            success: boolean;
+            files: unknown[];
+            total: number;
+            error?: string;
+        }>;
+        searchText: (params: unknown) => Promise<{
+            success: boolean;
+            results: unknown[];
+            total: number;
+            error?: string;
+        }>;
+        listSymbols: (params: unknown) => Promise<{
+            success: boolean;
+            symbols: unknown[];
+            total: number;
+            error?: string;
+        }>;
+        getSymbol: (params: unknown) => Promise<{
+            success: boolean;
+            symbol?: unknown;
+            file?: unknown;
+            references?: unknown[];
+            error?: string;
+        }>;
+        references: (params: unknown) => Promise<{
+            success: boolean;
+            results: unknown[];
+            total: number;
+            error?: string;
+        }>;
+        codeActions: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            filePath?: string;
+            actions: unknown[];
+            diagnostics: unknown[];
+            error?: string;
+        }>;
+        applyCodeAction: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            filePath?: string;
+            applied: boolean;
+            edits: unknown[];
+            diagnostics?: unknown[];
+            error?: string;
+        }>;
+        organizeImports: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            filePath?: string;
+            applied: boolean;
+            edits: unknown[];
+            diagnostics?: unknown[];
+            error?: string;
+        }>;
+        renameSymbol: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            filePath?: string;
+            applied: boolean;
+            edits: unknown[];
+            diagnostics?: unknown[];
+            error?: string;
+        }>;
+        languageServiceStatus: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            services: unknown[];
+            error?: string;
+        }>;
+        controlLanguageService: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            service?: unknown;
+            error?: string;
+        }>;
+        repairIndex: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            repaired: boolean;
+            removedFiles: string[];
+            rebuilt?: unknown;
+            durationMs: number;
+            error?: string;
+        }>;
+        dependencyGraph: (params: unknown) => Promise<{
+            success: boolean;
+            graph?: unknown;
+            error?: string;
+        }>;
+        createContextPack: (params: unknown) => Promise<{
+            success: boolean;
+            pack?: unknown;
+            error?: string;
+        }>;
+        updateContextPack: (params: unknown) => Promise<{
+            success: boolean;
+            pack?: unknown;
+            error?: string;
+        }>;
+        listContextPacks: (params: unknown) => Promise<{
+            success: boolean;
+            packs: unknown[];
+            error?: string;
+        }>;
+        materializeContextPack: (params: unknown) => Promise<{
+            success: boolean;
+            materialized?: unknown;
+            error?: string;
+        }>;
+        whatChanged: (params: unknown) => Promise<{
+            success: boolean;
+            isGitRepo: boolean;
+            rootDirectory: string;
+            summary: string;
+            changedFiles: unknown[];
+            diffStat?: string;
+            workPacket: string;
+            error?: string;
+        }>;
+    };
+    /**
+     * §2.9 review and §5.7 landing, as the surface sees them.
+     *
+     * Every one of these can answer `available: false`. That is not an error
+     * path to collapse into a catch: a host with no isolation substrate wired
+     * observes nothing, and a surface must be able to tell "this run changed
+     * nothing" from "nobody was watching".
+     */
+    /** ADE §9 step 6. `coordinationComplete` is false today in every case —
+     *  collisions are only what this host has seen since it started — so a
+     *  surface must render the notice rather than presenting the board as the
+     *  whole picture. */
+    /** ADE §5.5. Every call can report unavailable — a host with no session
+     *  substrate mounted has no sessions, which is different from having none
+     *  open, and a surface must be able to tell them apart. */
+    /** ADE §5.1. `complete: false` means a tracker could not be read, so the
+     *  inbox may be MISSING work — a short list is not the same as no work. */
+    /** ADE §5.8. `durable: false` means these facts vanish when the app
+     *  closes — a surface must say so rather than rendering them identically. */
+    knowledge?: {
+        list: (params: {
+            workspaceId: string;
+        }) => Promise<{
+            available: boolean;
+            entries: Array<{
+                id: string;
+                subject: string;
+                fact: string;
+                pinned?: boolean;
+                runId: string;
+                providerId?: string;
+                at: number;
+            }>;
+            durable: boolean;
+            reason?: string;
+        }>;
+        record: (params: {
+            workspaceId: string;
+            subject: string;
+            fact: string;
+            pinned?: boolean;
+            runId: string;
+            providerId?: string;
+        }) => Promise<{
+            ok: boolean;
+            reason?: string;
+            entry?: {
+                id: string;
+            };
+        }>;
+        forget: (params: {
+            workspaceId: string;
+            entryId: string;
+        }) => Promise<{
+            ok: boolean;
+            reason?: string;
+        }>;
+        context: (params: {
+            workspaceId: string;
+            maxChars?: number;
+        }) => Promise<{
+            available: boolean;
+            text: string;
+            complete: boolean;
+            omitted: Array<{
+                subject: string;
+                reason: string;
+            }>;
+            reason?: string;
+        }>;
+    };
+    intake?: {
+        sources: (params: Record<string, never>) => Promise<{
+            available: boolean;
+            sources: Array<{
+                sourceId: string;
+                label: string;
+                healthy: boolean;
+                problem?: string;
+            }>;
+            reason?: string;
+        }>;
+        list: (params: {
+            sourceId?: string;
+        }) => Promise<{
+            available: boolean;
+            items: Array<{
+                id: string;
+                sourceId: string;
+                externalId: string;
+                title: string;
+                detail?: string;
+                createdAt?: number;
+                url?: string;
+                claimState: string;
+                claimedBy?: string;
+                runId?: string;
+            }>;
+            complete: boolean;
+            failedSources: Array<{
+                sourceId: string;
+                problem: string;
+            }>;
+            reason?: string;
+        }>;
+        /** 🔴 A second claimant is REFUSED and told who won. Show `reason`
+         *  verbatim — the loser's next move depends on knowing it lost. */
+        claim: (params: {
+            itemId: string;
+            clientId: string;
+        }) => Promise<{
+            ok: boolean;
+            reason?: string;
+            heldBy?: string;
+            runId?: string;
+            claimState?: string;
+        }>;
+        release: (params: {
+            itemId: string;
+            clientId: string;
+        }) => Promise<{
+            ok: boolean;
+            reason?: string;
+            heldBy?: string;
+            claimState?: string;
+        }>;
+        dispatch: (params: {
+            itemId: string;
+            clientId: string;
+            runId: string;
+        }) => Promise<{
+            ok: boolean;
+            reason?: string;
+            heldBy?: string;
+            runId?: string;
+            claimState?: string;
+        }>;
+    };
+    session: {
+        list: (params: {
+            runId?: string;
+        }) => Promise<{
+            available: boolean;
+            sessions: Array<{
+                sessionId: string;
+                runId: string;
+                mode: string;
+                switchable: boolean;
+                hasProtocolChannel: boolean;
+                openedAt: number;
+                viewers: string[];
+                lease: {
+                    holder: string | null;
+                    heldSince: number | null;
+                    interventions: number;
+                };
+            }>;
+            reason?: string;
+        }>;
+        attach: (params: {
+            sessionId: string;
+            viewerId: string;
+        }) => Promise<{
+            ok: boolean;
+            reason?: string;
+        }>;
+        detach: (params: {
+            sessionId: string;
+            viewerId: string;
+        }) => Promise<{
+            ok: boolean;
+            reason?: string;
+        }>;
+        snapshot: (params: {
+            sessionId: string;
+        }) => Promise<{
+            available: boolean;
+            output: string;
+            truncated: boolean;
+            reason?: string;
+        }>;
+        /**
+         * Ordinary typing — §2.8. Honours the write lease WITHOUT seizing it.
+         *
+         * The routing (steer now, or queue for the next turn) is decided by the
+         * host from facts it owns; a surface supplies only what was typed.
+         * `delivered` says whether the agent already has it — see `sink`.
+         */
+        input: (params: {
+            sessionId: string;
+            viewerId: string;
+            data: string;
+        }) => Promise<{
+            ok: boolean;
+            code?: 'no_such_session' | 'lease_held';
+            disposition?: 'steer' | 'queue';
+            delivered?: boolean;
+            sink?: 'pty' | 'turn.steer' | 'turn.queue';
+            /**
+             * 🔴 The EFFECT of a `queue` disposition, with the address
+             * needed to act on it. `disposition` is the intent and cannot say
+             * whether it happened; a surface reading it as if it could is how
+             * this panel came to report a queue entry that did not exist.
+             */
+            queued?: {
+                instructionId: string;
+                conversationId: string;
+            };
+            reason?: string;
+        }>;
+        /** 🔴 Refused when ANOTHER human holds the lease, and the keystrokes are
+         *  NOT written in that case. Show `reason` verbatim. */
+        takeover: (params: {
+            sessionId: string;
+            viewerId: string;
+            data: string;
+        }) => Promise<{
+            ok: boolean;
+            lease?: {
+                holder: string | null;
+                heldSince: number | null;
+                interventions: number;
+            };
+            reason?: string;
+        }>;
+        release: (params: {
+            sessionId: string;
+            viewerId: string;
+        }) => Promise<{
+            ok: boolean;
+            reason?: string;
+        }>;
+        /**
+         * Change what renders into the session — ADE §2.8's "the user switches".
+         *
+         * 🔴 Offer it ONLY when the row says `switchable`. Every refusal names
+         * which half is missing, and today the honest answer is usually no: no
+         * composition attaches a vendor TUI, so most agents have exactly one
+         * mode. A control that is always present and always refuses teaches
+         * people to ignore it.
+         *
+         * Optional because a host predating the verb has none, and a panel must
+         * degrade to showing the mode rather than fail to mount.
+         */
+        setMode?: (params: {
+            sessionId: string;
+            mode: string;
+        }) => Promise<{
+            ok: boolean;
+            mode?: string;
+            reason?: string;
+        }>;
+        /**
+         * A session opened, closed, or gained or lost a viewer — ADE §2.8.
+         *
+         * 🔴 IDS AND COUNTS ONLY. Terminal bytes are per-viewer and large, so
+         * the substrate keeps them off the event feed on purpose; `snapshot` is
+         * the read path for output and stays a poll. A surface that treated this
+         * as an output stream would be waiting for bytes that never come.
+         *
+         * Optional because a host predating it has no such channel, and a panel
+         * must degrade to its one-shot list rather than fail to mount.
+         */
+        subscribeChanged?: (listener: (payload: unknown) => void) => () => void;
+    };
+    fleet?: {
+        view: (params: {
+            claimedPathsByRun?: Record<string, string[]>;
+        }) => Promise<{
+            runs: Array<{
+                runId: string;
+                conversationId?: string;
+                workspaceId?: string;
+                agentId?: string;
+                working: boolean;
+                claims: string[];
+                changes?: {
+                    added: number;
+                    modified: number;
+                    deleted: number;
+                };
+                diffComplete?: boolean;
+                contestedPaths: string[];
+            }>;
+            collisions: Array<{
+                scope: string;
+                wantedByRunId: string;
+                heldByRunId: string;
+                at: string;
+                stillHeld: boolean;
+            }>;
+            coordinationComplete: boolean;
+            observationComplete: boolean;
+            problems: string[];
+        }>;
+        /**
+         * Anything a board row is composed from moved — claims, collisions and
+         * run state (`coordination.event`), or change counts and diff trust
+         * (`run.observation`).
+         *
+         * Optional, so a host predating it leaves the panel on its manual
+         * refresh rather than failing to mount.
+         */
+        subscribeChanged?: (listener: (payload: unknown) => void) => () => void;
+    };
+    developmentCoordination?: {
+        /** Stable identity whose lease is owned and heartbeated by the host client. */
+        ownerId: string;
+        getState: (params: {
+            sessionId: string;
+        }) => Promise<{
+            schemaVersion: 1;
+            sessionId: string;
+            result: unknown;
+            state: object;
+        }>;
+        action: (params: {
+            sessionId: string;
+            action: 'goal.create' | 'goal.update' | 'goal.complete' | 'goal.cancel' | 'goal.steer' | 'loop.start' | 'loop.get' | 'loop.begin' | 'loop.finish' | 'loop.set_status' | 'ownership.acquire' | 'ownership.renew' | 'ownership.release' | 'handoff.create' | 'handoff.claim' | 'handoff.complete' | 'handoff.fail';
+            payload?: Record<string, unknown>;
+        }) => Promise<{
+            schemaVersion: 1;
+            sessionId: string;
+            result: unknown;
+            state: object;
+        }>;
+        subscribeChanged?: (listener: (payload: unknown) => void) => () => void;
+    };
+    review: {
+        snapshot: (params: {
+            runId: string;
+            poll?: boolean;
+        }) => Promise<{
+            available: boolean;
+            runId: string;
+            changes: Array<{
+                path: string;
+                kind: 'added' | 'modified' | 'deleted';
+            }>;
+            complete: boolean;
+            droppedEvents: number;
+            problems: string[];
+            reason?: string;
+        }>;
+        /**
+         * A run's tier-1 change set moved — §2.9.
+         *
+         * Payload carries `runId`; a pane watching one run FILTERS for itself.
+         * Optional, so a host predating it leaves the pane on manual refresh
+         * rather than failing to mount.
+         */
+        subscribeChanged?: (listener: (payload: unknown) => void) => () => void;
+        change: (params: {
+            runId: string;
+            path: string;
+        }) => Promise<{
+            available: boolean;
+            path: string;
+            before?: string;
+            after?: string;
+            binary: boolean;
+            truncated: boolean;
+            refusal?: string;
+        }>;
+        overlaps: (params: {
+            claimedPathsByRun?: Record<string, string[]>;
+        }) => Promise<{
+            available: boolean;
+            overlaps: Array<{
+                path: string;
+                runIds: string[];
+                kind: string;
+                unclaimed?: boolean;
+            }>;
+            incompleteRuns: string[];
+            complete: boolean;
+            reason?: string;
+        }>;
+    };
+    engineering: {
+        gitStatus: (params: unknown) => Promise<{
+            success: boolean;
+            isGitRepo: boolean;
+            rootDirectory: string;
+            branch?: string;
+            upstream?: string;
+            ahead?: number;
+            behind?: number;
+            clean: boolean;
+            files: unknown[];
+            raw?: string;
+            error?: string;
+        }>;
+        gitDiff: (params: unknown) => Promise<{
+            success: boolean;
+            isGitRepo: boolean;
+            rootDirectory: string;
+            diff: string;
+            truncated: boolean;
+            error?: string;
+        }>;
+        gitStage: (params: unknown) => Promise<{
+            success: boolean;
+            isGitRepo: boolean;
+            rootDirectory: string;
+            branch?: string;
+            upstream?: string;
+            ahead?: number;
+            behind?: number;
+            clean: boolean;
+            files: unknown[];
+            raw?: string;
+            error?: string;
+        }>;
+        gitUnstage: (params: unknown) => Promise<{
+            success: boolean;
+            isGitRepo: boolean;
+            rootDirectory: string;
+            branch?: string;
+            upstream?: string;
+            ahead?: number;
+            behind?: number;
+            clean: boolean;
+            files: unknown[];
+            raw?: string;
+            error?: string;
+        }>;
+        gitCommit: (params: unknown) => Promise<{
+            success: boolean;
+            isGitRepo: boolean;
+            rootDirectory: string;
+            branch?: string;
+            upstream?: string;
+            ahead?: number;
+            behind?: number;
+            clean: boolean;
+            files: unknown[];
+            raw?: string;
+            error?: string;
+        }>;
+        gitBranch: (params: unknown) => Promise<{
+            success: boolean;
+            isGitRepo: boolean;
+            rootDirectory: string;
+            branch?: string;
+            clean: boolean;
+            files: unknown[];
+            error?: string;
+        }>;
+        /** 🔴 Outward-facing. Refuses unless `confirmed: true` comes from a real
+         *  human action — never set as a constant by a caller. */
+        gitPush: (params: unknown) => Promise<{
+            success: boolean;
+            pushed: boolean;
+            remote?: string;
+            pushedBranch?: string;
+            error?: string;
+        }>;
+        /** 🔴 Outward-facing. Same rule as `gitPush`. */
+        gitCreatePullRequest: (params: unknown) => Promise<{
+            success: boolean;
+            created: boolean;
+            url?: string;
+            number?: number;
+            error?: string;
+        }>;
+        landingEnqueue: (params: import('@xenosystem/agent-interface-contract').LandingEnqueueRequest) => Promise<LandingQueueView>;
+        landingRemove: (params: import('@xenosystem/agent-interface-contract').LandingRemoveRequest) => Promise<LandingQueueView>;
+        landingStatus: (params: import('@xenosystem/agent-interface-contract').EngineeringRequestBase) => Promise<LandingQueueView>;
+        landingVerify: (params: import('@xenosystem/agent-interface-contract').LandingVerifyRequest) => Promise<import('@xenosystem/agent-interface-contract').LandingVerifyResponse>;
+        /** 🔴 Outward-facing: this merges into trunk. Confirmation is required
+         *  AND is not the gate — the host still refuses an unverified, stale or
+         *  overlapping combination. */
+        landingLand: (params: import('@xenosystem/agent-interface-contract').LandingLandRequest) => Promise<import('@xenosystem/agent-interface-contract').LandingLandResponse>;
+        discoverChecks: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            checks: unknown[];
+            packageManager?: 'npm';
+            error?: string;
+        }>;
+        runCheck: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            error?: string;
+        }>;
+        startBackgroundCheck: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory?: string;
+            run?: unknown;
+            error?: string;
+        }>;
+        listBackgroundRuns: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            runs: unknown[];
+            error?: string;
+        }>;
+        readBackgroundRunOutput: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory?: string;
+            run?: unknown;
+            error?: string;
+        }>;
+        stopBackgroundRun: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory?: string;
+            run?: unknown;
+            error?: string;
+        }>;
+        listRuns: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            runs: unknown[];
+            error?: string;
+        }>;
+        diagnostics: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            summary: string;
+            git?: unknown;
+            checks: unknown[];
+            recentRuns: unknown[];
+            backgroundRuns?: unknown[];
+            issues: unknown[];
+            error?: string;
+        }>;
+        listPatchReviews: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            items: unknown[];
+            error?: string;
+        }>;
+        enqueuePatchReview: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            item?: unknown;
+            items?: unknown[];
+            error?: string;
+        }>;
+        updatePatchReview: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            item?: unknown;
+            items?: unknown[];
+            error?: string;
+        }>;
+        reviewPatchSelection: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            item?: unknown;
+            selectedHunkIds: string[];
+            wouldChangeFiles: string[];
+            previewToken?: string;
+            conflicts?: Array<{
+                relativePath: string;
+                reason: string;
+                detail?: string;
+            }>;
+            applied?: boolean;
+            transactionId?: string;
+            error?: string;
+        }>;
+        listCheckpoints: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            checkpoints: unknown[];
+            error?: string;
+        }>;
+        compareCheckpoints: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            from?: unknown;
+            to?: unknown;
+            filesChanged: string[];
+            diff: string;
+            patches: unknown[];
+            error?: string;
+        }>;
+        restoreCheckpoint: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            checkpoint?: unknown;
+            previewDiff: string;
+            wouldRestoreFiles: string[];
+            previewToken?: string;
+            conflicts?: Array<{
+                relativePath: string;
+                reason: string;
+                detail?: string;
+            }>;
+            restored?: boolean;
+            restoredFiles?: string[];
+            transactionId?: string;
+            runtimeEvent?: unknown;
+            error?: string;
+        }>;
+        listSessions: (params: unknown) => Promise<{
+            success: boolean;
+            rootDirectory: string;
+            sessions: unknown[];
+            error?: string;
+        }>;
+        runtimeTimeline: (params: unknown) => Promise<import('@xenosystem/agent-interface-contract').EngineeringRuntimeTimelineResponse>;
+    };
+    runtimeEvents: {
+        append: (params: unknown) => Promise<{
+            success: boolean;
+            event?: unknown;
+            duplicate?: boolean;
+            error?: string;
+        }>;
+        list: (params: unknown) => Promise<{
+            success: boolean;
+            events: unknown[];
+            error?: string;
+        }>;
+        listSubagentTrace: (params: unknown) => Promise<{
+            success: boolean;
+            events: unknown[];
+            error?: string;
+        }>;
+        project: (params: unknown) => Promise<{
+            success: boolean;
+            projection?: unknown;
+            error?: string;
+        }>;
+        repair: (params: unknown) => Promise<{
+            success: boolean;
+            conversationId?: string;
+            scannedLineCount?: number;
+            validEventCount?: number;
+            corruptLineCount?: number;
+            duplicateEventCount?: number;
+            reordered?: boolean;
+            resequenced?: boolean;
+            backupPath?: string;
+            error?: string;
+        }>;
+        subscribeAppended: (callback: (payload: unknown) => void) => string;
+        unsubscribeAppended: (subscriptionId: string) => boolean;
+    };
+    subagents: {
+        createRun: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            error?: string;
+        }>;
+        createTeamAgentDelegation: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            hostManaged?: boolean;
+            route?: unknown;
+            policy?: unknown;
+            error?: string;
+        }>;
+        updateRun: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            error?: string;
+        }>;
+        getRun: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            error?: string;
+        }>;
+        listRuns: (params: unknown) => Promise<{
+            success: boolean;
+            runs: unknown[];
+            error?: string;
+        }>;
+        getAgentStatus: (params: unknown) => Promise<{
+            success: boolean;
+            status?: unknown;
+            error?: string;
+        }>;
+        matchCapabilities: (params: unknown) => Promise<{
+            success: boolean;
+            capabilityMatch?: unknown;
+            error?: string;
+        }>;
+        claimNextRun: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            error?: string;
+        }>;
+        launchQueuedRun: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            launched?: boolean;
+            adapterStatus?: unknown;
+            error?: string;
+        }>;
+        markRunRunning: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            error?: string;
+        }>;
+        markRunTerminal: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            error?: string;
+        }>;
+        heartbeatRun: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            error?: string;
+        }>;
+        cancelRun: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            error?: string;
+        }>;
+        cancelExecution: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            error?: string;
+        }>;
+        recoverExpiredRuns: (params: unknown) => Promise<{
+            success: boolean;
+            recovered: number;
+            failed: number;
+            timedOut?: number;
+            stale?: number;
+            runs: unknown[];
+            error?: string;
+        }>;
+        adapterStatus: (params?: unknown) => Promise<{
+            success: boolean;
+            statuses: unknown[];
+            error?: string;
+        }>;
+        hydrateExecutionAttempt: (params: unknown) => Promise<{
+            success: boolean;
+            run?: unknown;
+            attempts?: unknown[];
+            attempt?: unknown;
+            adapterStatus?: unknown;
+            error?: string;
+        }>;
+        schedulerStatus: (params?: unknown) => Promise<{
+            success: boolean;
+            status?: unknown;
+            error?: string;
+        }>;
+    };
+    cliControlPlane: {
+        inspectAppServer: (params: unknown) => Promise<{
+            success: boolean;
+            endpoint: string | null;
+            checkedAt: number;
+            status: string;
+            manifest: unknown;
+            openapi: unknown;
+            workflows: unknown[];
+            dashboards: unknown[];
+            versionSkewWarning?: string;
+            error?: string;
+        }>;
+        inspectWorkflowOperation: (params: unknown) => Promise<{
+            success: boolean;
+            endpoint: string | null;
+            checkedAt: number;
+            status: string;
+            method: string;
+            path: string | null;
+            operationId?: string;
+            response: unknown;
+            error?: string;
+        }>;
+        runThread: (params: unknown) => Promise<{
+            success: boolean;
+            endpoint: string | null;
+            checkedAt: number;
+            status: string;
+            method: 'thread.run';
+            messageCount: number;
+            text?: string;
+            messages?: unknown[];
+            cancelled?: boolean;
+            error?: string;
+        }>;
+        cancelThread: (params: unknown) => Promise<{
+            success: boolean;
+            checkedAt: number;
+            requestId: string | null;
+            cancelled: boolean;
+            error?: string;
+        }>;
+        runRemoteTurn: (params: unknown) => Promise<{
+            success: boolean;
+            checkedAt: number;
+            status: string;
+            method: 'xeno run --remote';
+            requestId: string;
+            runId?: string;
+            text?: string;
+            cancelled?: boolean;
+            error?: string;
+        }>;
+        remoteRunOperation: (params: unknown) => Promise<{
+            success: boolean;
+            endpoint: string | null;
+            checkedAt: number;
+            status: string;
+            action: string;
+            method: string;
+            path: string | null;
+            runId?: string;
+            response: unknown;
+            error?: string;
+        }>;
+        shareReplayOperation: (params: unknown) => Promise<{
+            success: boolean;
+            checkedAt: number;
+            status: string;
+            action: string;
+            method: string;
+            sourceId?: string;
+            pathLabel?: string;
+            response: unknown;
+            error?: string;
+        }>;
+        evalOperation: (params: unknown) => Promise<{
+            success: boolean;
+            checkedAt: number;
+            status: string;
+            action: string;
+            method: string;
+            suite?: string;
+            pathLabel?: string;
+            response: unknown;
+            error?: string;
+        }>;
+        orgMetadataOperation: (params: unknown) => Promise<{
+            success: boolean;
+            checkedAt: number;
+            status: string;
+            action: string;
+            method: string;
+            workspaceLabel?: string;
+            response: unknown;
+            error?: string;
+        }>;
+        mcpAuthOperation: (params: unknown) => Promise<{
+            success: boolean;
+            checkedAt: number;
+            status: string;
+            action: string;
+            method: string;
+            server?: string;
+            response: unknown;
+            error?: string;
+        }>;
+        githubAppOperation: (params: unknown) => Promise<{
+            success: boolean;
+            checkedAt: number;
+            status: string;
+            action: string;
+            method: string;
+            fixtureLabel?: string;
+            backendUrl?: string;
+            response: unknown;
+            error?: string;
+        }>;
+        cancelRemoteTurn: (params: unknown) => Promise<{
+            success: boolean;
+            checkedAt: number;
+            requestId: string | null;
+            cancelled: boolean;
+            error?: string;
+        }>;
+    };
+    workspacePolicy?: {
+        evaluate: (params: unknown) => Promise<{
+            allowed: boolean;
+            reason: string;
+            matchedVisibility?: string;
+            matchedScope?: unknown;
+        }>;
+        writeMemory: (params: unknown) => Promise<{
+            success: boolean;
+            entry?: unknown;
+            error?: string;
+        }>;
+        listMemory: (params: unknown) => Promise<{
+            success: boolean;
+            entries: unknown[];
+            error?: string;
+        }>;
+        registerArtifact: (params: unknown) => Promise<{
+            success: boolean;
+            artifact?: unknown;
+            error?: string;
+        }>;
+        listArtifacts: (params: unknown) => Promise<{
+            success: boolean;
+            artifacts: unknown[];
+            error?: string;
+        }>;
+        getArtifact: (params: unknown) => Promise<{
+            success: boolean;
+            result?: unknown;
+            error?: string;
+        }>;
+        deleteArtifact: (params: unknown) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        getTaskBoard: (params: unknown) => Promise<{
+            success: boolean;
+            board?: unknown;
+            error?: string;
+        }>;
+        upsertTask: (params: unknown) => Promise<{
+            success: boolean;
+            board?: unknown;
+            task?: unknown;
+            error?: string;
+        }>;
+        deleteTask: (params: unknown) => Promise<{
+            success: boolean;
+            board?: unknown;
+            error?: string;
+        }>;
+        listTaskBoards: (params: unknown) => Promise<{
+            success: boolean;
+            boards: unknown[];
+            error?: string;
+        }>;
+        snapshot: (params?: unknown) => Promise<{
+            success: boolean;
+            snapshot: unknown;
+        }>;
+    };
+    pluginMcp: {
+        snapshot: (params?: unknown) => Promise<{
+            success: boolean;
+            snapshot: unknown;
+        }>;
+        installPlugin: (params: unknown) => Promise<{
+            success: boolean;
+            plugin?: unknown;
+            error?: string;
+        }>;
+        installLocalPlugin: (params: unknown) => Promise<{
+            success: boolean;
+            plugin?: unknown;
+            error?: string;
+        }>;
+        activatePlugin: (params: unknown) => Promise<{
+            success: boolean;
+            plugin?: unknown;
+            error?: string;
+        }>;
+        deactivatePlugin: (params: unknown) => Promise<{
+            success: boolean;
+            plugin?: unknown;
+            error?: string;
+        }>;
+        uninstallPlugin: (params: unknown) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        updatePlugin: (params: unknown) => Promise<{
+            success: boolean;
+            plugin?: unknown;
+            error?: string;
+        }>;
+        setPluginTrust: (params: unknown) => Promise<{
+            success: boolean;
+            plugin?: unknown;
+            error?: string;
+        }>;
+        upsertMcpServer: (params: unknown) => Promise<{
+            success: boolean;
+            server?: unknown;
+            error?: string;
+        }>;
+        removeMcpServer: (params: unknown) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        setMcpApproval: (params: unknown) => Promise<{
+            success: boolean;
+            server?: unknown;
+            error?: string;
+        }>;
+        reloadMcp: (params: unknown) => Promise<{
+            success: boolean;
+            snapshot?: unknown;
+            connected: string[];
+            skipped: string[];
+            errors: Array<{
+                name: string;
+                error: string;
+            }>;
+            error?: string;
+        }>;
+        setMcpRegistryPolicy: (params: unknown) => Promise<{
+            success: boolean;
+            snapshot?: unknown;
+            error?: string;
+        }>;
+        setScopedPolicy: (params: unknown) => Promise<{
+            success: boolean;
+            policy?: unknown;
+            snapshot?: unknown;
+            error?: string;
+        }>;
+        deleteScopedPolicy: (params: unknown) => Promise<{
+            success: boolean;
+            snapshot?: unknown;
+            error?: string;
+        }>;
+        searchMarketplace: (params: unknown) => Promise<{
+            success: boolean;
+            listings: unknown[];
+            error?: string;
+        }>;
+        syncProjectMcp: (params: unknown) => Promise<{
+            success: boolean;
+            direction: 'import' | 'export';
+            configPath?: string;
+            synced: number;
+            servers: unknown[];
+            snapshot?: unknown;
+            error?: string;
+        }>;
+        callMcpTool: (params: unknown) => Promise<{
+            success: boolean;
+            result?: unknown;
+            preview?: unknown;
+            auditId?: string;
+            error?: string;
+            denial?: unknown;
+        }>;
+        getMcpPrompt: (params: unknown) => Promise<{
+            success: boolean;
+            result?: unknown;
+            preview?: unknown;
+            auditId?: string;
+            error?: string;
+            denial?: unknown;
+        }>;
+        readMcpResource: (params: unknown) => Promise<{
+            success: boolean;
+            result?: unknown;
+            preview?: unknown;
+            auditId?: string;
+            error?: string;
+            denial?: unknown;
+        }>;
+        preflightTrust: (params: unknown) => Promise<{
+            success: boolean;
+            allowed: boolean;
+            target?: unknown;
+            checks: unknown[];
+            plugin?: unknown;
+            server?: unknown;
+            reasons: string[];
+            remediation: unknown[];
+            denial?: unknown;
+            error?: string;
+        }>;
+    };
+    acp: {
+        listAgents: () => Promise<{
+            success: boolean;
+            agents: unknown[];
+            repaired?: boolean;
+            error?: string;
+        }>;
+        /**
+         * The provider catalog changed — by any surface, or by the host.
+         *
+         * Optional, so a host predating it leaves a surface on its own reloads
+         * rather than failing to mount.
+         */
+        subscribeCatalogChanged?: (listener: (payload: unknown) => void) => () => void;
+        listProviderCatalog: (refresh?: boolean) => Promise<{
+            success: boolean;
+            catalog?: unknown;
+            error?: string;
+        }>;
+        syncProviderCatalog: (refresh?: boolean) => Promise<{
+            success: boolean;
+            catalog?: unknown;
+            error?: string;
+        }>;
+        setProviderCatalogEnabled: (enabled: boolean) => Promise<{
+            success: boolean;
+            catalog?: unknown;
+            error?: string;
+        }>;
+        setCatalogProviderEnabled: (providerId: string, enabled: boolean) => Promise<{
+            success: boolean;
+            catalog?: unknown;
+            error?: string;
+        }>;
+        updateCatalogProvider: (providerId: string) => Promise<{
+            success: boolean;
+            catalog?: unknown;
+            error?: string;
+        }>;
+        setPreferredCatalogProvider: (providerId: string) => Promise<{
+            success: boolean;
+            catalog?: unknown;
+            error?: string;
+        }>;
+        getAgent: (id: string) => Promise<{
+            success: boolean;
+            agent?: unknown;
+            error?: string;
+        }>;
+        saveAgent: (input: unknown) => Promise<{
+            success: boolean;
+            agent?: unknown;
+            repaired?: boolean;
+            error?: string;
+        }>;
+        createFixtureAgent: (input?: unknown) => Promise<{
+            success: boolean;
+            agent?: unknown;
+            repaired?: boolean;
+            error?: string;
+        }>;
+        createLocalProviderAgent: (providerId: 'codex-local' | 'claude-local' | 'kimi' | 'grok' | 'agy' | 'opencode') => Promise<{
+            success: boolean;
+            agent?: unknown;
+            repaired?: boolean;
+            error?: string;
+        }>;
+        removeAgent: (id: string) => Promise<{
+            success: boolean;
+            removed: boolean;
+            error?: string;
+        }>;
+        testAgent: (id: string) => Promise<{
+            success: boolean;
+            protocolVersion?: number;
+            agentInfo?: unknown;
+            updateCount: number;
+            stopReason?: string;
+            diagnostics: unknown;
+            error?: string;
+        }>;
+        getProviderModels: (id: string, providerId?: string) => Promise<{
+            success: boolean;
+            result?: unknown;
+            error?: string;
+        }>;
+        certifyAgent: (id: string) => Promise<{
+            success: boolean;
+            result?: unknown;
+            agent?: unknown;
+            error?: string;
+        }>;
+        approveProvider: (id: string, providerId?: string) => Promise<{
+            success: boolean;
+            result?: unknown;
+            error?: string;
+        }>;
+        revokeProvider: (id: string, providerId?: string) => Promise<{
+            success: boolean;
+            result?: unknown;
+            error?: string;
+        }>;
+        runAgentPrompt: (params: unknown) => Promise<{
+            success: boolean;
+            result?: unknown;
+            status?: string;
+            events?: unknown[];
+            error?: string;
+            hostBinding?: import('@xenosystem/agent-interface-contract').AgentSessionHostBindingV1;
+            activeLane?: import('@xenosystem/agent-interface-contract').ProviderLaneProjectionV1;
+            lanes?: import('@xenosystem/agent-interface-contract').ProviderLaneProjectionV1[];
+        }>;
+        cancelAgentPrompt: (params: unknown) => Promise<{
+            success: boolean;
+            cancelled: boolean;
+            error?: string;
+        }>;
+        closeConversation: (params: unknown) => Promise<{
+            success: boolean;
+            closedSessionCount: number;
+            error?: string;
+        }>;
+        getDiagnostics: () => Promise<{
+            success: boolean;
+            diagnostics?: unknown;
+            error?: string;
+        }>;
+        getCapabilitySnapshot?: (params: {
+            conversationId: string;
+            sessionId?: string;
+            acpAgentConfigId?: string;
+        }) => Promise<{
+            success: boolean;
+            capabilitySnapshot?: unknown;
+            error?: string;
+        }>;
+        invokeCommand?: (params: {
+            conversationId: string;
+            sessionId?: string;
+            commandId: string;
+            rawInput?: string;
+            args?: Record<string, unknown>;
+            idempotencyKey?: string;
+        }) => Promise<{
+            success: boolean;
+            commandEvent?: unknown;
+            error?: string;
+        }>;
+    };
+    webSearch?: {
+        search: (query: WebSearchIpcInput, count?: number) => Promise<{
+            success: boolean;
+            results: Array<{
+                title: string;
+                url: string;
+                snippet: string;
+            }>;
+            error?: string;
+        }>;
+    };
+    usage: {
+        snapshot?: (input: import('@xenosystem/agent-interface-contract').AgentUsageRequest) => Promise<import('@xenosystem/agent-interface-contract').AgentUsageResult>;
+        summary: (entityType: string, entityId: string, period: string) => Promise<unknown>;
+        byModel: () => Promise<unknown>;
+        topAgents: () => Promise<unknown>;
+    };
+    audit?: {
+        snapshot?: (input: import('@xenosystem/agent-interface-contract').AgentAuditRequest) => Promise<import('@xenosystem/agent-interface-contract').AgentAuditResult>;
+        list: (limit?: number) => Promise<unknown>;
+        log: (action: string, entity: string, entityId: string, details: string) => Promise<unknown>;
+    };
+    exportBackup: {
+        exportJson: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            path?: string;
+            error?: string;
+        }>;
+        exportCsv: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            path?: string;
+            error?: string;
+        }>;
+        createBackup: (name?: string | ({
+            name?: string;
+        } & ScopedIpcParams)) => Promise<{
+            success: boolean;
+            backup?: unknown;
+            error?: string;
+        }>;
+        listBackups: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            backups: Array<{
+                id: string;
+                name: string;
+                createdAt: string;
+                size: number;
+                fileName: string;
+            }>;
+        }>;
+        downloadBackup: (id: string | ({
+            id?: string;
+            backupId?: string;
+        } & ScopedIpcParams)) => Promise<{
+            success: boolean;
+            path?: string;
+            error?: string;
+        }>;
+        deleteBackup: (id: string | ({
+            id?: string;
+            backupId?: string;
+        } & ScopedIpcParams)) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+        importBackup: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            restored?: {
+                workspaces: boolean;
+                conversations: number;
+                settings: boolean;
+            };
+            restoredConversations?: Array<{
+                sourceId: string;
+                conversationId: string;
+            }>;
+            error?: string;
+        }>;
+        getSettings: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            settings: {
+                autoBackupEnabled: boolean;
+                frequency: string;
+                retentionDays: number;
+                lastError?: string;
+            };
+        }>;
+        updateSettings: (settings: Record<string, unknown>) => Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+    };
+    capture: {
+        screenshot: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            localPath: string | null;
+            clipboardCopied: boolean;
+            width?: number;
+            height?: number;
+            dataUrl?: string;
+            error: string | null;
+        }>;
+        getHistory: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            captures: Array<{
+                name: string;
+                path: string;
+                size: number;
+                date: string;
+                type: 'image' | 'video' | 'gif';
+                thumbnailDataUrl: string | null;
+            }>;
+            error: string | null;
+        }>;
+        deleteCapture: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        openFolder: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        copyToClipboard: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        getImageDataUrl: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            dataUrl: string | null;
+            error: string | null;
+        }>;
+        saveAnnotated: (dataUrl: string | ({
+            dataUrl: string;
+            originalPath?: string;
+        } & ScopedIpcParams), originalPath?: string) => Promise<{
+            success: boolean;
+            localPath: string | null;
+            error: string | null;
+        }>;
+        copyAnnotatedToClipboard: (dataUrl: string | ({
+            dataUrl: string;
+        } & ScopedIpcParams)) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        onHotkeyScreenshot: (callback: () => void) => void;
+        offHotkeyScreenshot: () => void;
+    };
+    whisper?: {
+        copyToClipboard: (text: string) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        saveEntry: (entry: {
+            id: string;
+            text: string;
+            language: string;
+            duration: number;
+            timestamp: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        getHistory: () => Promise<{
+            success: boolean;
+            entries: Array<{
+                id: string;
+                text: string;
+                language: string;
+                duration: number;
+                timestamp: string;
+            }>;
+            error: string | null;
+        }>;
+        deleteEntry: (id: string) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        clearHistory: () => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        getSettings: () => Promise<{
+            success: boolean;
+            settings: {
+                language: string;
+                autoCopy: boolean;
+                quality: 'fast' | 'accurate';
+            };
+            error: string | null;
+        }>;
+        updateSettings: (updates: Record<string, unknown>) => Promise<{
+            success: boolean;
+            settings?: {
+                language: string;
+                autoCopy: boolean;
+                quality: 'fast' | 'accurate';
+            };
+            error: string | null;
+        }>;
+        transcribe: (data: {
+            audioBase64: string;
+            language?: string;
+            mimeType?: string;
+        }) => Promise<{
+            success: boolean;
+            text: string;
+            error: string | null;
+        }>;
+        onHotkeyToggle: (callback: () => void) => void;
+        offHotkeyToggle: () => void;
+    };
+    files: {
+        getRoots: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            roots: Array<{
+                id: string;
+                name: string;
+                path: string;
+                icon: string;
+                fileCount: number;
+                totalSize: number;
+            }>;
+            error: string | null;
+        }>;
+        list: (dirPath: PathIpcInput) => Promise<{
+            success: boolean;
+            files: Array<{
+                name: string;
+                path: string;
+                size: number;
+                modified: string;
+                type: 'file' | 'directory';
+                extension: string;
+            }>;
+            error: string | null;
+        }>;
+        listExternal: (dirPath: PathIpcInput) => Promise<{
+            success: boolean;
+            files: Array<{
+                name: string;
+                path: string;
+                size: number;
+                modified: string;
+                type: 'file' | 'directory';
+                extension: string;
+            }>;
+            error: string | null;
+        }>;
+        open: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        openExternal: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        showInExplorer: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        showInExplorerExternal: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        delete: (filePath: PathIpcInput) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        getDiskUsage: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            usage: {
+                total: number;
+                byDirectory: Record<string, number>;
+            };
+            error: string | null;
+        }>;
+        rename: (oldPath: string | ({
+            oldPath: string;
+            newName: string;
+        } & ScopedIpcParams), newName?: string) => Promise<{
+            success: boolean;
+            newPath?: string;
+            error: string | null;
+        }>;
+        openRoot: (params?: ScopedIpcParams) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+    };
+    uiAssetPipeline?: {
+        status: (pipelineRoot?: string) => Promise<{
+            success: boolean;
+            pipelineRoot: string;
+            scriptPath: string;
+            defaultOutputDirectory: string;
+            python: string;
+            error: string | null;
+        }>;
+        pickImage: () => Promise<{
+            success: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        pickOutputDirectory: (defaultPath?: string) => Promise<{
+            success: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        readProject: (projectPath: string) => Promise<{
+            success: boolean;
+            projectPath?: string;
+            inputImage?: string;
+            profile?: 'gamedev' | 'animation';
+            extractionMode?: 'essential' | 'full' | 'both';
+            agentMode?: 'cli' | 'api';
+            paths?: {
+                summaryPath?: string;
+                combinedSummaryPath?: string;
+                finalDir?: string;
+                qualityReportMd?: string;
+                mountingMd?: string;
+                rawResultsPath?: string;
+            };
+            error: string | null;
+        }>;
+        deleteProject: (params: {
+            projectPath: string;
+            outputDirectory: string;
+        }) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        run: (params: {
+            imagePath: string;
+            outputDirectory: string;
+            pipelineRoot?: string;
+            profile: 'gamedev' | 'animation';
+            extractionMode: 'essential' | 'full' | 'both';
+            agentMode: 'cli' | 'api';
+            chromaBgMode?: 'chroma-bg-dynamic-color' | 'chroma-bg-fixed-color';
+            maxWorkers?: number;
+            cleanOutput?: boolean;
+            overwrite?: boolean;
+            apiKey?: string;
+            edgeCleanup?: boolean;
+            alphaEdgeDefringe?: boolean;
+            deriveStateVariants?: boolean;
+            extractElements?: string[];
+            skipInventory?: boolean;
+            finalDir?: string;
+        }) => Promise<{
+            success: boolean;
+            jobId: string | null;
+            error: string | null;
+        }>;
+        cancel: (jobId: string) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        openPath: (targetPath: string) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+        onEvent: (callback: (event: {
+            jobId: string;
+            type: string;
+            stream?: 'stdout' | 'stderr';
+            text?: string;
+            success?: boolean;
+            exitCode?: number;
+            durationMs?: number;
+            paths?: {
+                summaryPath?: string;
+                combinedSummaryPath?: string;
+                finalDir?: string;
+                qualityReportMd?: string;
+                mountingMd?: string;
+                rawResultsPath?: string;
+            };
+            finalAssetCount?: number;
+            qualityStatus?: string | null;
+            qualityErrorCount?: number;
+            qualityWarningCount?: number;
+            error?: string;
+            stderr?: string;
+            command?: string;
+            pipelineRoot?: string;
+            outputDirectory?: string;
+            assets?: Array<{
+                slug: string;
+                name: string;
+                stage?: 'queued' | 'chroma' | 'transparent' | 'final' | 'error';
+                status?: string;
+                path?: string;
+                chromaPath?: string;
+                transparentPath?: string;
+                finalPath?: string;
+                index?: number;
+                total?: number;
+                size?: number;
+            }>;
+            asset?: {
+                slug: string;
+                name: string;
+                stage?: 'queued' | 'chroma' | 'transparent' | 'final' | 'error';
+                status?: string;
+                path?: string;
+                chromaPath?: string;
+                transparentPath?: string;
+                finalPath?: string;
+                index?: number;
+                total?: number;
+                size?: number;
+            };
+        }) => void) => void;
+        offEvent: () => void;
+    };
+    materialGenerator?: {
+        pickImage: () => Promise<{
+            success: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        readImage: (filePath: string) => Promise<{
+            success: boolean;
+            dataUrl: string | null;
+            error: string | null;
+        }>;
+        pickOutputDirectory: (defaultName?: string) => Promise<{
+            success: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        pickPackage: () => Promise<{
+            success: boolean;
+            path: string | null;
+            error: string | null;
+        }>;
+        readPackage: (packagePath: string) => Promise<{
+            success: boolean;
+            manifestPath: string | null;
+            directory: string | null;
+            manifest: any;
+            maps: Array<{
+                key: string;
+                fileName: string;
+                dataUrl: string;
+            }>;
+            error: string | null;
+        }>;
+        findEngineProjects: (engine: 'unreal' | 'unity' | 'godot' | 'folder') => Promise<{
+            success: boolean;
+            projects: Array<{
+                engine: 'unreal' | 'unity' | 'godot' | 'folder';
+                name: string;
+                path: string;
+                importDirectory: string;
+                source: 'open-process' | 'recent-scan' | 'manual';
+            }>;
+            error: string | null;
+        }>;
+        pickEngineProject: (engine: 'unreal' | 'unity' | 'godot' | 'folder') => Promise<{
+            success: boolean;
+            project: {
+                engine: 'unreal' | 'unity' | 'godot' | 'folder';
+                name: string;
+                path: string;
+                importDirectory: string;
+                source: 'open-process' | 'recent-scan' | 'manual';
+            } | null;
+            error: string | null;
+        }>;
+        writeOutput: (params: {
+            outputDirectory: string;
+            files: Array<{
+                relativePath: string;
+                dataUrl?: string;
+                content?: string;
+            }>;
+        }) => Promise<{
+            success: boolean;
+            outputDirectory?: string;
+            files: string[];
+            error: string | null;
+        }>;
+        runUnrealImportScript: (params: {
+            packageDirectory: string;
+            projectName?: string;
+            projectPath?: string;
+        }) => Promise<{
+            success: boolean;
+            remoteImported: boolean;
+            error: string | null;
+            details: string | null;
+            setupRequired: boolean;
+        }>;
+        openPath: (targetPath: string) => Promise<{
+            success: boolean;
+            error: string | null;
+        }>;
+    };
+    system?: {
+        health: () => Promise<{
+            cpu: {
+                model: string;
+                cores: number;
+                usage: number;
+            };
+            ram: {
+                total: number;
+                free: number;
+                used: number;
+                usagePercent: number;
+            };
+            gpu: {
+                name: string;
+                vendor: string;
+                vramMb: number | null;
+                driverVersion: string | null;
+            } | null;
+            disk: {
+                total: number;
+                free: number;
+                used: number;
+                xenoUsage: number;
+            };
+            network: {
+                online: boolean;
+            };
+            os: {
+                platform: string;
+                arch: string;
+                release: string;
+            };
+            xenoAppsSize: Record<string, number>;
+        }>;
+        cleanOldVersions: () => Promise<{
+            success: boolean;
+            cleaned: number;
+        }>;
+    };
+    support?: {
+        createBundle: (params?: unknown) => Promise<{
+            success: boolean;
+            path?: string;
+            summary?: Record<string, unknown>;
+            error?: string;
+        }>;
+        repairAll: (params?: unknown) => Promise<{
+            success: boolean;
+            repaired: Array<{
+                id: string;
+                success: boolean;
+                detail?: string;
+                error?: string;
+            }>;
+            durationMs: number;
+            error?: string;
+        }>;
+        runMigrations: () => Promise<{
+            success: boolean;
+            version: number;
+            migrated: boolean;
+            path: string;
+            checks: Array<{
+                id: string;
+                status: string;
+                detail?: string;
+                error?: string;
+            }>;
+            durationMs: number;
+            error?: string;
+        }>;
+        profile: () => Promise<unknown>;
+    };
+    errorReporting?: {
+        report: (data: {
+            message: string;
+            stack?: string;
+            component?: string;
+            userDescription?: string;
+        }) => Promise<{
+            success: boolean;
+        }>;
+        getCrashLog: () => Promise<{
+            success: boolean;
+            log: string;
+        }>;
+        clearCrashLog: () => Promise<{
+            success: boolean;
+        }>;
+    };
+    onDeepLink?: (callback: (url: string) => void) => void;
+    offDeepLink?: () => void;
+}
+declare global {
+    interface Window {
+        xenoAPI: XenoAPI;
+        XENO_API_KEY?: string;
+        GEMINI_API_TOKEN?: string;
+        SpeechRecognition?: SpeechRecognitionConstructor;
+        webkitSpeechRecognition?: SpeechRecognitionConstructor;
+    }
+}
+export {};
+//# sourceMappingURL=platformApiTypes.d.ts.map