@farmslot/protocol 0.73.2 → 0.74.1

package/dist/client-cache/registry.d.ts

@@ -0,0 +1,1365 @@
+import { providerAccountsDependencies, providerAccountsObservationParams, providerAccountsStoredData } from '../contracts/provider-accounts.js';
+import type { ConfigGitHubAccountsResult } from '../rpc/config.js';
+import type { GatewayStatusResult } from '../rpc/gateway.js';
+import { prForSlotObservationParams, prForSlotStoredData, prReviewCommentsObservationParams, prReviewCommentsStoredData, prStatusObservationParams, prStatusStoredData } from '../rpc/pr-observations.js';
+import type { UpstreamObservation } from '../rpc/resource-observers.js';
+import { runnerModelCatalogObservationParams, runnerModelCatalogStoredData, runnerVisibleModelsObservationParams, runnerVisibleModelsStoredData } from '../rpc/runner-models.js';
+import { analyticsParams, assessmentHistoryParams, observerEvidenceParams, sessionContextParams, triageParams } from './d07-domains.js';
+import { type ResourceKey } from './keys.js';
+import { nativeHistoryParams } from './native-history.js';
+export interface ResourceQueryRetention {
+    readonly maxEntries: number;
+    readonly maxBytes: number;
+    readonly cohort?: string;
+    readonly groups?: readonly string[];
+}
+export interface ResourceQueryDefinition {
+    persisted: boolean;
+    maxBytes: number;
+    /** Shared bound across this method's canonical query entries. */
+    retention?: ResourceQueryRetention;
+    /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+    timeoutMs?: number;
+    /** Becomes true only when the slice's writers and read stamps are implemented. */
+    live: boolean;
+    /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+    collector?: 'github' | 'gateway-update' | 'providers';
+    /**
+     * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+     * observation; `undefined` means the gateway omitted one and the reply is refused.
+     */
+    sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+    /** Optional durable projection for replies that also carry live-only diagnostics. */
+    persistedData?(data: unknown): unknown;
+    /** Requires the experimental server observed-read dispatch contract. */
+    requiresObservedRead?: boolean;
+    requiresWorkspaceRead?: boolean;
+    /** Observation parameters can exclude imperative variants of an existing read method. */
+    normalizeParams?(params: unknown): unknown;
+    retentionGroups?(params: unknown): string[];
+    dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+}
+export declare const UPSTREAM_QUERY_MAX_BYTES: number;
+declare function planningObservationParams(params: unknown): Record<string, unknown>;
+declare function roadmapListObservationParams(params: unknown): Record<string, unknown>;
+declare function workerInventoryParams(params: unknown): Record<string, unknown>;
+declare function prListObservationParams(params: unknown): Record<string, unknown>;
+declare function upstreamRefreshObservationParams(params: unknown): Record<string, never>;
+declare function githubAccountsStoredData(data: unknown): ConfigGitHubAccountsResult;
+/** Durable update facts only: Git/process diagnostics, paths and PIDs stay in the live reply. */
+declare function gatewayStatusStoredData(data: unknown): GatewayStatusResult;
+/** A local slot answer (no PR lookup applies) is explicit, not a missing upstream observation. */
+declare function prForSlotSourceObservation(data: unknown): UpstreamObservation | null | undefined;
+/** Only a runner with no catalog source answers without an observation; collected sources never do. */
+declare function runnerModelCatalogSourceObservation(data: unknown): UpstreamObservation | null | undefined;
+export declare function upstreamSourceObservation(data: unknown): UpstreamObservation | undefined;
+/** Closed to runtime registration. Each migration changes its owning definition here. */
+export declare const RESOURCE_QUERY_DEFINITIONS: {
+    "gateway.status": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+            cohort: string;
+        };
+        timeoutMs: number;
+        live: true;
+        collector: "gateway-update";
+        sourceObservation: typeof upstreamSourceObservation;
+        persistedData: typeof gatewayStatusStoredData;
+        normalizeParams: typeof upstreamRefreshObservationParams;
+        dependencies: () => {
+            family: "gateway-update";
+            scope: "gateway";
+        }[];
+    };
+    "config.githubAccounts": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+            cohort: string;
+        };
+        timeoutMs: number;
+        live: true;
+        collector: "github";
+        sourceObservation: typeof upstreamSourceObservation;
+        persistedData: typeof githubAccountsStoredData;
+        normalizeParams: typeof upstreamRefreshObservationParams;
+        dependencies: () => {
+            family: "upstream";
+            integration: "github";
+            queryId: string;
+        }[];
+    };
+    "pr.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+            cohort: string;
+        };
+        timeoutMs: number;
+        live: true;
+        collector: "github";
+        sourceObservation: typeof upstreamSourceObservation;
+        normalizeParams: typeof prListObservationParams;
+        dependencies: (params: unknown) => ({
+            family: "upstream";
+            integration: "github";
+            queryId: string;
+            scope?: undefined;
+        } | {
+            family: "runs";
+            scope: "farm";
+            integration?: undefined;
+            queryId?: undefined;
+        } | {
+            family: "slots";
+            scope: "farm";
+            integration?: undefined;
+            queryId?: undefined;
+        } | {
+            family: "workers";
+            scope: "farm";
+            integration?: undefined;
+            queryId?: undefined;
+        } | {
+            family: "configuration";
+            scope: "farm";
+            integration?: undefined;
+            queryId?: undefined;
+        } | {
+            family: "sources";
+            scope: "farm";
+            integration?: undefined;
+            queryId?: undefined;
+        })[];
+    };
+    "pr.status": {
+        persistedData: typeof prStatusStoredData;
+        normalizeParams: typeof prStatusObservationParams;
+        dependencies: (params: unknown) => ResourceKey[];
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            readonly maxEntries: number;
+            readonly maxBytes: number;
+            readonly cohort: "upstream";
+        };
+        timeoutMs: 30000;
+        live: true;
+        collector: "github";
+        sourceObservation: typeof upstreamSourceObservation;
+    };
+    "pr.forSlot": {
+        sourceObservation: typeof prForSlotSourceObservation;
+        persistedData: typeof prForSlotStoredData;
+        normalizeParams: typeof prForSlotObservationParams;
+        dependencies: (params: unknown) => ResourceKey[];
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            readonly maxEntries: number;
+            readonly maxBytes: number;
+            readonly cohort: "upstream";
+        };
+        timeoutMs: 30000;
+        live: true;
+        collector: "github";
+    };
+    "pr.reviewComments": {
+        persistedData: typeof prReviewCommentsStoredData;
+        normalizeParams: typeof prReviewCommentsObservationParams;
+        dependencies: (params: unknown) => ResourceKey[];
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            readonly maxEntries: number;
+            readonly maxBytes: number;
+            readonly cohort: "upstream";
+        };
+        timeoutMs: 30000;
+        live: true;
+        collector: "github";
+        sourceObservation: typeof upstreamSourceObservation;
+    };
+    "runner.modelCatalog": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+            cohort: string;
+        };
+        timeoutMs: number;
+        live: true;
+        collector: "providers";
+        sourceObservation: typeof runnerModelCatalogSourceObservation;
+        persistedData: typeof runnerModelCatalogStoredData;
+        normalizeParams: typeof runnerModelCatalogObservationParams;
+        dependencies: (params: unknown) => ResourceKey[];
+    };
+    "providerAccounts.snapshot": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+            cohort: string;
+        };
+        timeoutMs: number;
+        live: true;
+        collector: "providers";
+        sourceObservation: typeof upstreamSourceObservation;
+        persistedData: typeof providerAccountsStoredData;
+        normalizeParams: typeof providerAccountsObservationParams;
+        dependencies: typeof providerAccountsDependencies;
+    };
+    "runner.visibleModels.get": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        requiresObservedRead: true;
+        persistedData: typeof runnerVisibleModelsStoredData;
+        normalizeParams: typeof runnerVisibleModelsObservationParams;
+        dependencies: (_params: unknown, readerId?: string) => {
+            family: "profiles";
+            scope: "owner";
+            ownerId: string;
+        }[];
+    };
+    "prWatch.list": ResourceQueryDefinition;
+    "prWatch.get": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "prRules.list": ResourceQueryDefinition;
+    "prReview.get": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "prPush.list": ResourceQueryDefinition;
+    "assessment.list": {
+        normalizeParams: typeof assessmentHistoryParams;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "assessment.get": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "assessment.summary": ResourceQueryDefinition;
+    "assessment.report": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "assessment.status": {
+        dependencies: () => ResourceKey[];
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        /** Observation parameters can exclude imperative variants of an existing read method. */
+        normalizeParams?(params: unknown): unknown;
+        retentionGroups?(params: unknown): string[];
+    };
+    "decision.advice.get": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        dependencies: (params: unknown) => ResourceKey[];
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+    };
+    "intelligence.triage.get": {
+        normalizeParams: typeof triageParams;
+        dependencies: (params: unknown) => ResourceKey[];
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+    };
+    "analytics.query": {
+        normalizeParams: typeof analyticsParams;
+        dependencies: () => {
+            family: "analytics";
+            scope: "farm";
+        }[];
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+    };
+    "copilot.status": {
+        timeoutMs: number;
+        dependencies: () => ({
+            readonly family: "copilot";
+            readonly ownerId: "gateway-copilot";
+        } | {
+            family: "runs";
+            scope: "farm";
+        } | {
+            family: "slots";
+            scope: "farm";
+        } | {
+            family: "workers";
+            scope: "farm";
+        } | {
+            family: "configuration";
+            scope: "farm";
+        } | {
+            family: "sources";
+            scope: "farm";
+        })[];
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        /** Observation parameters can exclude imperative variants of an existing read method. */
+        normalizeParams?(params: unknown): unknown;
+        retentionGroups?(params: unknown): string[];
+    };
+    "chat.context": {
+        dependencies: () => ({
+            readonly family: "copilot";
+            readonly ownerId: "gateway-copilot";
+        } | {
+            family: "runs";
+            scope: "farm";
+            collection?: undefined;
+        } | {
+            family: "slots";
+            scope: "farm";
+            collection?: undefined;
+        } | {
+            family: "decisions";
+            scope: "farm";
+            collection?: undefined;
+        } | {
+            family: "planning";
+            collection: "dispatch-queue";
+            scope?: undefined;
+        })[];
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        /** Observation parameters can exclude imperative variants of an existing read method. */
+        normalizeParams?(params: unknown): unknown;
+        retentionGroups?(params: unknown): string[];
+    };
+    "chat.observerEvidence": {
+        normalizeParams: typeof observerEvidenceParams;
+        dependencies: () => {
+            readonly family: "copilot";
+            readonly ownerId: "gateway-copilot";
+        }[];
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+    };
+    "chat.sessionContext": {
+        normalizeParams: typeof sessionContextParams;
+        dependencies: (params: unknown) => ({
+            readonly family: "copilot";
+            readonly ownerId: "gateway-copilot";
+        } | {
+            sessionId: string;
+            family: "copilot";
+            ownerId: "gateway-copilot";
+        })[];
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+    };
+    "config.projects": {
+        persisted: true;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        maxBytes: number;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        /** Observation parameters can exclude imperative variants of an existing read method. */
+        normalizeParams?(params: unknown): unknown;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "config.pools": ResourceQueryDefinition;
+    "config.pool": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "config.pool.raw": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "config.project": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "config.templates": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "config.templateOptions": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "config.templatePreview": {
+        normalizeParams: (params: unknown) => Record<string, unknown>;
+        persisted: boolean;
+        maxBytes: number;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "llm.config.get": ResourceQueryDefinition;
+    "llm.auth.list": ResourceQueryDefinition;
+    "llm.tiers": ResourceQueryDefinition;
+    "native.session.read": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        requiresObservedRead: true;
+        normalizeParams: typeof nativeHistoryParams;
+        dependencies: (params: unknown, nativeReaderId?: string) => {
+            family: "profiles" | "native-session";
+            scope: "owner";
+            ownerId: string;
+        }[] | {
+            family: "profiles";
+            nodeId: string;
+            ownerId: string;
+        }[] | {
+            workerId?: string | undefined;
+            sessionId?: string | undefined;
+            family: "native-session";
+            nodeId: string;
+            ownerId: string;
+        }[];
+    };
+    "native.session.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        requiresObservedRead: true;
+        dependencies: (params: unknown, nativeReaderId?: string) => {
+            family: "profiles" | "native-session";
+            scope: "owner";
+            ownerId: string;
+        }[] | {
+            family: "profiles";
+            nodeId: string;
+            ownerId: string;
+        }[] | {
+            workerId?: string | undefined;
+            sessionId?: string | undefined;
+            family: "native-session";
+            nodeId: string;
+            ownerId: string;
+        }[];
+    };
+    "native.session.catalog": {
+        persisted: false;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        requiresObservedRead: true;
+        dependencies: (params: unknown, nativeReaderId?: string) => {
+            family: "profiles" | "native-session";
+            scope: "owner";
+            ownerId: string;
+        }[] | {
+            family: "profiles";
+            nodeId: string;
+            ownerId: string;
+        }[] | {
+            workerId?: string | undefined;
+            sessionId?: string | undefined;
+            family: "native-session";
+            nodeId: string;
+            ownerId: string;
+        }[];
+    };
+    "native.profile.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        requiresObservedRead: true;
+        dependencies: (params: unknown, nativeReaderId?: string) => {
+            family: "profiles" | "native-session";
+            scope: "owner";
+            ownerId: string;
+        }[] | {
+            family: "profiles";
+            nodeId: string;
+            ownerId: string;
+        }[] | {
+            workerId?: string | undefined;
+            sessionId?: string | undefined;
+            family: "native-session";
+            nodeId: string;
+            ownerId: string;
+        }[];
+    };
+    "native.profile.status": {
+        persisted: false;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        requiresObservedRead: true;
+        dependencies: (params: unknown, nativeReaderId?: string) => {
+            family: "profiles" | "native-session";
+            scope: "owner";
+            ownerId: string;
+        }[] | {
+            family: "profiles";
+            nodeId: string;
+            ownerId: string;
+        }[] | {
+            workerId?: string | undefined;
+            sessionId?: string | undefined;
+            family: "native-session";
+            nodeId: string;
+            ownerId: string;
+        }[];
+    };
+    "fs.list": ResourceQueryDefinition;
+    "fs.read": ResourceQueryDefinition;
+    "git.status": ResourceQueryDefinition;
+    "git.diff": {
+        maxBytes: number;
+        persisted: boolean;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        /** Observation parameters can exclude imperative variants of an existing read method. */
+        normalizeParams?(params: unknown): unknown;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "git.show": ResourceQueryDefinition;
+    "git.branchDiff": ResourceQueryDefinition;
+    "native.session.workspace.list": ResourceQueryDefinition;
+    "native.session.workspace.read": ResourceQueryDefinition;
+    "native.session.workspace.changes": ResourceQueryDefinition;
+    "native.session.workspace.diff": {
+        maxBytes: number;
+        persisted: boolean;
+        /** Shared bound across this method's canonical query entries. */
+        retention?: ResourceQueryRetention;
+        /** Preserve a migrated read's existing transport timeout when it differs from the default. */
+        timeoutMs?: number;
+        /** Becomes true only when the slice's writers and read stamps are implemented. */
+        live: boolean;
+        /** Gateway-owned upstream collection, enabled only after stamped reads are implemented. */
+        collector?: "github" | "gateway-update" | "providers";
+        /**
+         * The reply's upstream source state. `null` marks an explicit answer that is not an upstream
+         * observation; `undefined` means the gateway omitted one and the reply is refused.
+         */
+        sourceObservation?(data: unknown): UpstreamObservation | null | undefined;
+        /** Optional durable projection for replies that also carry live-only diagnostics. */
+        persistedData?(data: unknown): unknown;
+        /** Requires the experimental server observed-read dispatch contract. */
+        requiresObservedRead?: boolean;
+        requiresWorkspaceRead?: boolean;
+        /** Observation parameters can exclude imperative variants of an existing read method. */
+        normalizeParams?(params: unknown): unknown;
+        retentionGroups?(params: unknown): string[];
+        dependencies(params: unknown, nativeReaderId?: string): ResourceKey[];
+    };
+    "tmux.worker.list": {
+        requiresObservedRead: true;
+        persisted: false;
+        maxBytes: number;
+        timeoutMs: number;
+        live: true;
+        normalizeParams: typeof workerInventoryParams;
+        dependencies: (params: unknown) => ({
+            family: "workers";
+            nodeId: string;
+        } | {
+            family: "workers";
+            scope: "farm";
+        })[];
+    };
+    "dispatch.queue.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        normalizeParams: typeof planningObservationParams;
+        dependencies: () => {
+            family: "planning";
+            collection: "dispatch-queue";
+        }[];
+    };
+    "workGraph.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        normalizeParams: typeof planningObservationParams;
+        dependencies: () => {
+            family: "planning";
+            collection: "work-graphs";
+        }[];
+    };
+    "workGraph.get": {
+        persisted: false;
+        maxBytes: number;
+        live: true;
+        normalizeParams: typeof planningObservationParams;
+        dependencies: (params: unknown) => {
+            family: "planning";
+            collection: "work-graphs";
+            itemId: string;
+        }[];
+    };
+    "backlog.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        normalizeParams: typeof planningObservationParams;
+        dependencies: () => {
+            family: "planning";
+            collection: "backlog";
+        }[];
+    };
+    "roadmap.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        normalizeParams: typeof roadmapListObservationParams;
+        dependencies: () => ({
+            family: "planning";
+            collection: "roadmap";
+            scope?: undefined;
+        } | {
+            family: "planning";
+            collection: "backlog";
+            scope?: undefined;
+        } | {
+            family: "runs";
+            scope: "farm";
+            collection?: undefined;
+        })[];
+    };
+    "roadmap.get": {
+        persisted: false;
+        maxBytes: number;
+        live: true;
+        normalizeParams: typeof planningObservationParams;
+        dependencies: (params: unknown) => ({
+            family: "planning";
+            collection: "roadmap";
+            itemId?: undefined;
+            scope?: undefined;
+        } | {
+            family: "planning";
+            collection: "roadmap";
+            itemId: string;
+            scope?: undefined;
+        } | {
+            family: "planning";
+            collection: "backlog";
+            itemId?: undefined;
+            scope?: undefined;
+        } | {
+            family: "planning";
+            collection: "work-graphs";
+            itemId?: undefined;
+            scope?: undefined;
+        } | {
+            family: "runs";
+            scope: "farm";
+            collection?: undefined;
+            itemId?: undefined;
+        })[];
+    };
+    "sources.status": {
+        persisted: true;
+        maxBytes: number;
+        timeoutMs: number;
+        live: true;
+        dependencies: () => {
+            family: "sources";
+            scope: "farm";
+        }[];
+    };
+    "run.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        dependencies: () => {
+            family: "runs";
+            scope: "farm";
+        }[];
+    };
+    "run.get": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        dependencies: (params: unknown) => ({
+            family: "run";
+            runId: string;
+            scope?: undefined;
+        } | {
+            family: "runs";
+            scope: "farm";
+            runId?: undefined;
+        })[];
+    };
+    "decision.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        dependencies: () => {
+            family: "decisions";
+            scope: "farm";
+        }[];
+    };
+    "family.observability.get": {
+        persisted: false;
+        maxBytes: number;
+        live: true;
+        dependencies: (params: unknown) => ({
+            family: "family";
+            familyId: string;
+            scope?: undefined;
+        } | {
+            family: "decisions";
+            scope: "farm";
+            familyId?: undefined;
+        })[];
+    };
+    "run.recipeRunsForRun": {
+        persisted: false;
+        maxBytes: number;
+        timeoutMs: number;
+        live: true;
+        dependencies: (params: unknown) => ({
+            family: "run";
+            runId: string;
+        } | {
+            family: "artifacts";
+            runId: string;
+        })[];
+    };
+    "run.slotHistory": {
+        persisted: false;
+        maxBytes: number;
+        live: true;
+        dependencies: () => ({
+            family: "runs";
+            scope: "farm";
+        } | {
+            family: "slots";
+            scope: "farm";
+        })[];
+    };
+    "run.forSlot": {
+        persisted: false;
+        maxBytes: number;
+        live: true;
+        dependencies: (params: unknown) => ({
+            family: "runs";
+            scope: "farm";
+            slotId?: undefined;
+        } | {
+            family: "slot";
+            slotId: string;
+            scope?: undefined;
+        })[];
+    };
+    "run.recipeRunsForSlot": {
+        persisted: false;
+        maxBytes: number;
+        timeoutMs: number;
+        live: true;
+        dependencies: (params: unknown) => ({
+            family: "runs";
+            scope: "farm";
+            slotId?: undefined;
+        } | {
+            family: "slot";
+            slotId: string;
+            scope?: undefined;
+        })[];
+    };
+    "run.tags.list": {
+        persisted: false;
+        maxBytes: number;
+        live: true;
+        dependencies: () => {
+            family: "runs";
+            scope: "farm";
+        }[];
+    };
+    "fleet.status": {
+        requiresObservedRead: true;
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        normalizeParams: (params: unknown) => {};
+        dependencies: () => {
+            family: "slots";
+            scope: "farm";
+        }[];
+    };
+    "nodes.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        timeoutMs: number;
+        live: true;
+        dependencies: () => {
+            family: "node";
+            scope: "farm";
+        }[];
+    };
+    "runtime.capability.list": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        dependencies: () => ({
+            family: "capabilities";
+            scope?: undefined;
+        } | {
+            family: "sources";
+            scope: "farm";
+        })[];
+    };
+    "runtime.capability.status": {
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        dependencies: () => ({
+            family: "capabilities";
+            scope?: undefined;
+        } | {
+            family: "sources";
+            scope: "farm";
+        })[];
+    };
+    "task.progress": {
+        requiresObservedRead: true;
+        persisted: true;
+        maxBytes: number;
+        retention: {
+            maxEntries: number;
+            maxBytes: number;
+        };
+        live: true;
+        dependencies: (params: unknown) => ({
+            family: "progress";
+            runId: string;
+        } | {
+            family: "run";
+            runId: string;
+        } | {
+            family: "artifacts";
+            runId: string;
+        })[] | {
+            family: "slot";
+            slotId: string;
+        }[];
+    };
+};
+export type ResourceReadMethod = keyof typeof RESOURCE_QUERY_DEFINITIONS;
+export type ResourceCollectorReadMethod = {
+    [Method in ResourceReadMethod]: (typeof RESOURCE_QUERY_DEFINITIONS)[Method] extends {
+        collector: string;
+    } ? Method : never;
+}[ResourceReadMethod];
+/** Advertise only collectors whose owning read and notification contract are enabled. */
+export declare function resourceCollectorReadMethods(): ResourceCollectorReadMethod[];
+export interface ResourceCollectorQuery {
+    id: string;
+    method: ResourceCollectorReadMethod;
+    params: unknown;
+}
+/** Collector selectors use exactly the same closed normalization as client query identities. */
+export declare function resourceCollectorQuery(method: unknown, params?: unknown): ResourceCollectorQuery;
+export declare function resourceReadTimeout(method: ResourceReadMethod): number | undefined;
+declare const queryData: unique symbol;
+export interface ResourceQuery<T = unknown> {
+    readonly id: string;
+    readonly method: ResourceReadMethod;
+    readonly params: unknown;
+    readonly dependencies: readonly ResourceKey[];
+    readonly persisted: boolean;
+    readonly maxBytes: number;
+    readonly retention?: ResourceQueryRetention;
+    readonly live: boolean;
+    readonly collector?: 'github' | 'gateway-update' | 'providers';
+    readonly sourceObservation?: (data: unknown) => UpstreamObservation | null | undefined;
+    readonly persistedData?: (data: unknown) => unknown;
+    readonly requiresObservedRead?: boolean;
+    readonly requiresWorkspaceRead?: boolean;
+    readonly [queryData]?: T;
+}
+/** Experimental, portable query factory; mutations and streams are never registered here. */
+export declare function resourceQuery<T = unknown>(method: ResourceReadMethod, params?: unknown, nativeReaderId?: string): ResourceQuery<T>;
+/** The server stamps only migrated reads, before entering their existing handlers. */
+export declare function resourceDependenciesForRead(method: string, params: unknown, nativeReaderId?: string): ResourceKey[] | undefined;
+export {};
+//# sourceMappingURL=registry.d.ts.map