@cavi-ai/api-client/extensions/cavi

export type AgentMemoryFile = {
    filename: string;
    content: string;
    lastModified: number;
};

export type AgentMemorySnapshot = {
    agentId: string;
    activeFiles: AgentMemoryFile[];
    journalCount: number;
    lastJournalDate: string | null;
};

export declare function appendCaviApiPath(basePath: string, relativePath?: string | null, options?: CaviApiPathAppendOptions): string;

export declare function appendHttpQuery(path: string, query?: Record<string, string | number | boolean | undefined>): string;

export declare function backfillCanonicalTeam(team: TeamRegistryTeamConfig): OperatorRegistryTeam;

export declare function buildAgentMainSessionKey(params: {
    agentId: string | null | undefined;
    mainKey?: string | null | undefined;
}): string;

export declare function buildLibraryClipPayload(input: LibraryClipInput): LibraryClipRequest;

export declare function buildLibraryClipSchemaSnapshot(): LibraryClipSchemaSnapshot;

export declare function buildLibraryManualFileClipInput(input: LibraryManualFileClipInput): LibraryClipInput;

export declare function buildPortalApiErrorEnvelope<TContract extends string, TData>(params: PortalApiEnvelopeBase & {
    contract: TContract;
    data: TData;
    error: PortalApiError;
    generatedAt?: number;
}): PortalApiResponseEnvelope<TContract, TData>;

export declare function buildPortalApiRequestEnvelope<TContract extends string, TPayload>(params: PortalApiEnvelopeBase & {
    contract: TContract;
    payload: TPayload;
    requestedAt?: number;
}): PortalApiRequestEnvelope<TContract, TPayload>;

export declare function buildPortalApiSuccessEnvelope<TContract extends string, TData>(params: PortalApiEnvelopeBase & {
    contract: TContract;
    data: TData;
    generatedAt?: number;
}): PortalApiResponseEnvelope<TContract, TData>;

export declare function buildPortalMemoryEnvelope<TSchemaContract extends string, TPayload>(params: {
    clientId: string;
    teamSlug: string;
    memberId: string;
    memoryKey: string;
    schemaContract: TSchemaContract;
    payload: TPayload;
    updatedAt?: number;
    portalId?: string;
    feature?: string;
    library?: PortalLibraryRef;
}): PortalMemoryEnvelope<TSchemaContract, TPayload>;

export declare function buildPortalTtsVoiceOptions(params: {
    providers?: readonly PortalTtsProviderLike[];
    activeProviderId?: string;
    dashboardVoices?: Record<string, PortalTtsDashboardVoiceLike>;
}): PortalTtsVoiceOption[];

export declare const CAVI_CONTROL_API_ENDPOINTS: {
    readonly costHistory: "/api/plugins/cavi-control/cost/history";
    readonly scoringModel: "/api/plugins/cavi-control/scoring/model";
    readonly projectBoard: {
        readonly root: "/api/plugins/cavi-control/kanban";
        readonly profile: "/api/plugins/cavi-control/kanban/profile";
        readonly sprint: "/api/plugins/cavi-control/kanban/sprint";
        readonly backlog: "/api/plugins/cavi-control/kanban/backlog";
        readonly call: "/api/plugins/cavi-control/kanban/call";
        readonly backlogItem: (itemId: string) => string;
    };
    readonly operator: {
        readonly root: "/cavi-control/api/operator";
        readonly snapshot: "/cavi-control/api/operator/snapshot";
        readonly status: "/cavi-control/api/operator/status";
        readonly registry: "/cavi-control/api/operator/registry";
        readonly tasks: "/cavi-control/api/operator/tasks";
        readonly task: (taskId: string) => string;
        readonly taskDiscourse: (taskId: string) => string;
        readonly memory: "/cavi-control/api/operator/memory";
        readonly workerReady: "/cavi-control/api/operator/worker/ready";
        readonly workerTasks: "/cavi-control/api/operator/worker/tasks";
    };
    readonly portalMemorySnapshot: (teamSlug: string, memberId: string, memoryKey: string) => string;
};

export declare const CAVI_CONTROL_BASE_PATH: "/cavi-control";

export declare const CAVI_CONTROL_OPERATOR_API: {
    readonly root: "/cavi-control/api/operator";
    readonly snapshot: "/cavi-control/api/operator/snapshot";
    readonly status: "/cavi-control/api/operator/status";
    readonly registry: "/cavi-control/api/operator/registry";
    readonly tasks: "/cavi-control/api/operator/tasks";
    readonly task: (taskId: string) => string;
    readonly taskDiscourse: (taskId: string) => string;
    readonly memory: "/cavi-control/api/operator/memory";
    readonly workerReady: "/cavi-control/api/operator/worker/ready";
    readonly workerTasks: "/cavi-control/api/operator/worker/tasks";
};

export declare const CAVI_CONTROL_OPERATOR_API_BASE: "/cavi-control/api/operator";

/**
 * The gateway mounts the operator API at two paths: the canonical
 * `/cavi-control/api/operator` and a generic plugin route
 * `/api/plugins/cavi-control/operator`. `operator-control-live` issues each
 * request against the canonical path with this plugin-alias path as a fallback,
 * so both tables are kept key-for-key identical.
 */
export declare const CAVI_CONTROL_OPERATOR_API_PLUGIN_ALIAS: {
    readonly root: "/api/plugins/cavi-control/operator";
    readonly snapshot: "/api/plugins/cavi-control/operator/snapshot";
    readonly status: "/api/plugins/cavi-control/operator/status";
    readonly registry: "/api/plugins/cavi-control/operator/registry";
    readonly tasks: "/api/plugins/cavi-control/operator/tasks";
    readonly task: (taskId: string) => string;
    readonly taskDiscourse: (taskId: string) => string;
    readonly memory: "/api/plugins/cavi-control/operator/memory";
    readonly workerReady: "/api/plugins/cavi-control/operator/worker/ready";
    readonly workerTasks: "/api/plugins/cavi-control/operator/worker/tasks";
};

export declare const CAVI_CONTROL_OPERATOR_API_PLUGIN_ALIAS_BASE: "/api/plugins/cavi-control/operator";

export declare const CAVI_CONTROL_OPERATOR_RPC_METHOD_LIST: ("operator.status" | "operator.registry.get" | "operator.snapshot" | "operator.memory.list" | "operator.tasks.list" | "operator.tasks.get" | "discourse.tree" | "operator.worker.ready" | "operator.worker.tasks.list" | "operator.worker.tasks.get")[];

export declare const CAVI_CONTROL_OPERATOR_RPC_METHODS: {
    readonly status: "operator.status";
    readonly registry: "operator.registry.get";
    readonly snapshot: "operator.snapshot";
    readonly memoryList: "operator.memory.list";
    readonly tasksList: "operator.tasks.list";
    readonly tasksGet: "operator.tasks.get";
    readonly discourseTree: "discourse.tree";
    readonly workerReady: "operator.worker.ready";
    readonly workerTasksList: "operator.worker.tasks.list";
    readonly workerTasksGet: "operator.worker.tasks.get";
};

export declare const CAVI_SURFACE_CONTRACTS: Record<string, SurfaceContract>;

export type CaviApiPathAppendOptions = {
    boundaryLabel?: string;
    errorPrefix?: string;
};

export type CaviControlAdapterFallbackProvider = GatewaySnapshotFallbackProvider & {
    cavi?: CaviControlAdapterFallbacks;
};

export type CaviControlAdapterFallbacks = {
    projectBoardWorkspace?: ProjectBoardWorkspaceSnapshot | (() => ProjectBoardWorkspaceSnapshot);
    operatorControl?: OperatorControlSnapshot | (() => OperatorControlSnapshot);
    taskDiscourse?: TaskDiscourseSnapshot | ((taskId: string) => TaskDiscourseSnapshot);
};

export type CaviControlAdapters = {
    loadSessionsListRaw: (params: {
        includeGlobal?: boolean;
        includeUnknown?: boolean;
        includeDerivedTitles?: boolean;
        limit?: number;
        activeMinutes?: number;
        search?: string;
        label?: string;
        spawnedBy?: string;
        agentId?: string;
    }) => Promise<SessionsListPayload & {
        hash?: string;
        count?: number;
        ts?: number;
        path?: string;
    }>;
    loadSessionsUsageRaw: (params: {
        key?: string;
        limit?: number;
        includeContextWeight?: boolean;
        startDate?: string;
        endDate?: string;
    }) => Promise<SessionsUsagePayload>;
    loadSessionsPreviewRaw: (params: {
        keys: string[];
        limit?: number;
        maxChars?: number;
    }) => Promise<SessionsPreviewPayload>;
    loadSessionDetailRaw: (params: {
        key: string;
        previewLimit?: number;
        maxChars?: number;
    }) => Promise<{
        key?: string;
        row?: unknown | null;
        usageSession?: unknown | null;
        preview?: unknown | null;
        errors?: {
            usage?: string | null;
        };
    }>;
    patchSessionRaw: (params: {
        key: string;
        label?: string | null;
        thinkingLevel?: string | null;
        fastMode?: boolean | null;
        verboseLevel?: string | null;
        reasoningLevel?: string | null;
    }) => Promise<void>;
    loadOverview: () => Promise<DataEnvelope<OverviewSnapshot>>;
    loadAgentRuns: (filters: AgentRunsFilters) => Promise<DataEnvelope<GatewaySessionRunsSnapshot>>;
    loadRunDetail: (key: string) => Promise<DataEnvelope<GatewaySessionRunDetailSnapshot>>;
    loadRoutingMatrix: (windowDays: number) => Promise<DataEnvelope<RoutingMatrixSnapshot>>;
    loadIncidents: () => Promise<DataEnvelope<IncidentsSnapshot>>;
    loadOperatorControl: () => Promise<DataEnvelope<OperatorControlSnapshot>>;
    loadProjectBoardWorkspace: () => Promise<DataEnvelope<ProjectBoardWorkspaceSnapshot>>;
    loadTaskDiscourse: (taskId: string) => Promise<DataEnvelope<TaskDiscourseSnapshot>>;
    loadFleetLibrary: () => Promise<FleetLibrarySnapshot>;
    loadCostHistory: (range: CostHistoryRange) => Promise<DataEnvelope<CostHistorySnapshot>>;
    createProjectBoardEmail: (draft: ProjectBoardEmailDraft) => Promise<MutationResult<ProjectBoardEmailRecipient>>;
    updateProjectBoardEmail: (emailId: string, draft: ProjectBoardEmailDraft) => Promise<MutationResult<ProjectBoardEmailRecipient>>;
    removeProjectBoardEmail: (emailId: string) => Promise<MutationResult<{
        id: string;
    }>>;
    createProjectBoardBacklogItem: (draft: ProjectBoardBacklogDraft) => Promise<MutationResult<ProjectBoardBacklogItem>>;
    updateProjectBoardBacklogItem: (itemId: string, draft: ProjectBoardBacklogDraft) => Promise<MutationResult<ProjectBoardBacklogItem>>;
    callProjectBoard: (request: ProjectBoardCallRequest) => Promise<MutationResult<ProjectBoardCallResult>>;
};

export declare class CaviControlApiClient extends BaseHttpApiClient {
    readonly endpoints: {
        readonly costHistory: "/api/plugins/cavi-control/cost/history";
        readonly scoringModel: "/api/plugins/cavi-control/scoring/model";
        readonly projectBoard: {
            readonly root: "/api/plugins/cavi-control/kanban";
            readonly profile: "/api/plugins/cavi-control/kanban/profile";
            readonly sprint: "/api/plugins/cavi-control/kanban/sprint";
            readonly backlog: "/api/plugins/cavi-control/kanban/backlog";
            readonly call: "/api/plugins/cavi-control/kanban/call";
            readonly backlogItem: (itemId: string) => string;
        };
        readonly operator: {
            readonly root: "/cavi-control/api/operator";
            readonly snapshot: "/cavi-control/api/operator/snapshot";
            readonly status: "/cavi-control/api/operator/status";
            readonly registry: "/cavi-control/api/operator/registry";
            readonly tasks: "/cavi-control/api/operator/tasks";
            readonly task: (taskId: string) => string;
            readonly taskDiscourse: (taskId: string) => string;
            readonly memory: "/cavi-control/api/operator/memory";
            readonly workerReady: "/cavi-control/api/operator/worker/ready";
            readonly workerTasks: "/cavi-control/api/operator/worker/tasks";
        };
        readonly portalMemorySnapshot: (teamSlug: string, memberId: string, memoryKey: string) => string;
    };
    readonly request: HttpApiTransport;
    constructor(options: HttpApiClientOptions);
    getOperatorSnapshot<T = unknown>(): Promise<T>;
    getPortalDashboard<T = unknown>(path: string): Promise<T>;
    postJson<T = unknown>(path: string, body: unknown, idempotencyKey?: string): Promise<T>;
}

export type CaviTeamPortalId = string;

export declare function configureCanonicalOperatorRegistry(snapshot: OperatorRegistrySnapshot | null | undefined): void;

export declare function configureCanonicalTeamRegistry(config: TeamRegistryConfig | null | undefined): void;

export declare function configureTeamRegistryConfig(config: TeamRegistryConfig | null | undefined): void;

export declare function createCaviControlAdapterFallbackProvider(): CaviControlAdapterFallbackProvider;

export declare function createCaviControlAdapters(opts: {
    gatewayBaseUrl: string;
    authToken: string | null;
    apiBaseUrl?: string | null;
    client?: GatewayWebSocketClient | null;
    defaultHeaders?: Record<string, string>;
    fallbackMode?: CaviSnapshotFallbackMode;
    fallbackProvider?: CaviControlAdapterFallbackProvider | null;
    snapshotFallbacks?: CreateGatewayWsSnapshotLoadersOptions["snapshotFallbacks"];
    costHistoryFallback?: CreateGatewayWsSnapshotLoadersOptions["costHistoryFallback"];
    caviFallbacks?: CaviControlAdapterFallbackProvider["cavi"];
    resolveSnapshotBinding?: CreateGatewayWsSnapshotLoadersOptions["resolveBinding"];
}): CaviControlAdapters;

export declare function createCaviSnapshotFallbackProvider(): GatewaySnapshotFallbackProvider;

export declare function createContractGap(key: MobileGatewaySurfaceKey, note?: string): MobileGatewayContractGap;

export declare function createEmptyDelegatedTransport(): OperatorControlSnapshot["status"]["delegatedFirstClassAgents"];

export declare function createEmptyOperatorMemory(): OperatorControlSnapshot["memory"];

export declare function createEmptyOperatorRegistry(): OperatorControlSnapshot["registryDetail"];

export declare function createEmptyOperatorSectionStatus(): OperatorControlSnapshot["sectionStatus"];

export declare function createEmptyOperatorStatus(): OperatorControlSnapshot["status"];

export declare function createEmptyOperatorTasks(): OperatorControlSnapshot["tasks"];

export declare function createEmptyWorkerReady(): OperatorControlSnapshot["workerReady"];

export declare function createEmptyWorkerTasks(): OperatorControlSnapshot["workerTasks"];

export declare function createEmptyWorkerTransport(): OperatorControlSnapshot["status"]["worker"];

export declare function createHermesTeamRegistry(config?: TeamRegistryConfig): TeamRegistry;

export declare function createOpenClawTeamRegistry(config?: TeamRegistryConfig): TeamRegistry;

export declare function createOperatorSectionStatus<TKey extends OperatorControlSectionKey>(params: {
    available: boolean;
    authoritative: boolean;
    error: string | null;
    sampleLimit: number | null;
}): OperatorControlSnapshot["sectionStatus"][TKey];

export declare function createPortalTtsAgentVoiceAssignment(params: {
    agentKey: string;
    voice: PortalTtsVoiceOption;
    assignedAt?: string;
}): PortalTtsAgentVoiceAssignment;

export declare function createProjectBoardLiveHelpers(requestJson: JsonHttpRequest, options?: {
    workboardRpc?: OpenClawWorkboardRpc | null;
}): ProjectBoardLiveHelpers;

export declare function createProjectBoardMutations(requestJson: JsonHttpRequest, projectBoardLive: ProjectBoardLiveHelpers): ProjectBoardMutations;

export declare function createTeamRegistry(config?: TeamRegistryConfig, options?: CreateTeamRegistryOptions): TeamRegistry;

export declare function createTeamRegistryFromSnapshot(snapshot: OperatorRegistrySnapshot | null | undefined, options?: CreateTeamRegistryOptions): TeamRegistry;

export type CreateTeamRegistryOptions = {
    provider?: TeamRegistryProviderKind | null;
};

/** Default project-board asset directory — neutral, not a fleet-agent slug. */
export declare const DEFAULT_PROJECT_BOARD_ASSET_DIR = "project-board";

export type DelegationNode = {
    taskId: string;
    agentId: string;
    objective: string;
    status: string;
    children: DelegationNode[];
    events: DiscourseEvent[];
    cost: {
        tokens: number;
        costUsd: number;
        durationMs: number | null;
    };
};

export type DiscourseBlockerData = {
    blockerCode: string;
    description: string;
    severity: "low" | "medium" | "high" | "critical";
    retryable: boolean;
};

export type DiscourseBlockerEvent = DiscourseEventBase & {
    type: "discourse.blocker";
    data: DiscourseBlockerData;
};

export type DiscourseCompletionData = {
    outcome: "ok" | "error" | "timeout" | "partial";
    resultSummary: string;
    tokensUsed: number;
    costUsd: number;
    durationMs: number;
};

export type DiscourseCompletionEvent = DiscourseEventBase & {
    type: "discourse.completion";
    data: DiscourseCompletionData;
};

export type DiscourseDecisionData = {
    question: string;
    chosenApproach: string;
    rationale: string;
    alternatives: Array<{
        approach: string;
        reasonRejected: string;
    }>;
};

export type DiscourseDecisionEvent = DiscourseEventBase & {
    type: "discourse.decision";
    data: DiscourseDecisionData;
};

export type DiscourseDelegationData = {
    targetAgentId: string;
    objective: string;
    teamId?: string;
    rationale?: string;
};

export type DiscourseDelegationEvent = DiscourseEventBase & {
    type: "discourse.delegation";
    data: DiscourseDelegationData;
};

export type DiscourseDispatchData = {
    targetAgentId: string;
    objective: string;
    tier: string;
    packetType: string;
    approachRationale?: string;
    alternativesConsidered?: string[];
};

export type DiscourseDispatchEvent = DiscourseEventBase & {
    type: "discourse.dispatch";
    data: DiscourseDispatchData;
};

export type DiscourseEscalationData = {
    reason: string;
    target: string;
    severity?: "low" | "medium" | "high" | "critical";
};

export type DiscourseEscalationEvent = DiscourseEventBase & {
    type: "discourse.escalation";
    data: DiscourseEscalationData;
};

export type DiscourseEvent = DiscourseDispatchEvent | DiscourseDelegationEvent | DiscourseDecisionEvent | DiscourseBlockerEvent | DiscourseResolutionEvent | DiscourseStatusEvent | DiscourseEscalationEvent | DiscourseCompletionEvent | DiscourseSpawnDedupEvent | DiscourseSpawnGuardEvent | DiscourseSpawnBudgetEvent;

export type DiscourseEventType = "discourse.dispatch" | "discourse.delegation" | "discourse.decision" | "discourse.blocker" | "discourse.resolution" | "discourse.status" | "discourse.escalation" | "discourse.completion" | "discourse.spawn.dedup" | "discourse.spawn.guard" | "discourse.spawn.budget";

export type DiscourseResolutionData = {
    originalBlockerEventId: string;
    resolution: string;
    method: "retry" | "workaround" | "escalate" | "skip";
};

export type DiscourseResolutionEvent = DiscourseEventBase & {
    type: "discourse.resolution";
    data: DiscourseResolutionData;
};

export type DiscourseSpawnBudgetData = {
    recentFailureCount: number;
    blockStrikeCount: number;
    retryAfterMs: number;
};

export type DiscourseSpawnBudgetEvent = DiscourseEventBase & {
    type: "discourse.spawn.budget";
    data: DiscourseSpawnBudgetData;
};

export type DiscourseSpawnDedupData = {
    targetAgentId: string;
    existingChildSessionKey: string;
    ttlMs: number;
};

export type DiscourseSpawnDedupEvent = DiscourseEventBase & {
    type: "discourse.spawn.dedup";
    data: DiscourseSpawnDedupData;
};

export type DiscourseSpawnGuardData = {
    targetAgentId: string;
    failureCode: string;
    strikeCount: number;
    ttlMs: number;
};

export type DiscourseSpawnGuardEvent = DiscourseEventBase & {
    type: "discourse.spawn.guard";
    data: DiscourseSpawnGuardData;
};

export type DiscourseStatusData = {
    prevState: string;
    nextState: string;
    note?: string;
};

export type DiscourseStatusEvent = DiscourseEventBase & {
    type: "discourse.status";
    data: DiscourseStatusData;
};

export type EnrichedAgentRun = AgentRun & {
    taskId: string | null;
    taskState: OperatorTaskState | null;
    taskObjective: string | null;
    taskOwner: string | null;
    teamId: string | null;
    verification: string | null;
    discourseTaskId: string | null;
};

export declare const fallbackProjectBoardWorkspace: ProjectBoardWorkspaceSnapshot;

export type FleetLibrarySnapshot = {
    generatedAt: number;
    teams: TeamLibraryStatus[];
    sigmund: {
        status: "online" | "offline" | "unknown";
        lastIngestAt: number | null;
        totalProcessed: number;
    };
};

export declare const GATEWAY_KANBAN_BOARD_PATH: string;

export declare const GATEWAY_KANBAN_TASKS_PATH: string;

export declare const GATEWAY_RPC_METHODS: {
    readonly discourseTree: "discourse.tree";
};

export declare const GATEWAY_WS_PATH: string;

export type GatewayTargets = {
    rawBase: string;
    httpBase: string;
    wsBase: string;
    authToken: string | null;
    wsPath: string;
};

export declare function getConfiguredGatewayBaseUrl(): string | null;

export declare function getConfiguredTeamRegistry(options?: CreateTeamRegistryOptions): TeamRegistry;

export declare function getFleetLibraryRef(): PortalLibraryRef;

export declare function getMobileGatewayEndpointContract(key: MobileGatewaySurfaceKey): MobileGatewayEndpointContract;

export declare function getMobileGatewayEndpointPath(key: MobileGatewaySurfaceKey): string;

export declare function getOperatorTeamLookupKeys(team: OperatorRegistryTeam): string[];

export declare function getPortalTeamCode(portalId: CaviTeamPortalId): string;

export declare function getPortalTeamIdentity(portalId: CaviTeamPortalId): OperatorRegistryTeam;

export declare function getPortalTeamSectorSlug(portalId: CaviTeamPortalId): string;

export declare function getPortalTeamSlug(portalId: CaviTeamPortalId): string;

export declare function getPortalTtsProviderLabel(provider: PortalTtsProviderLike): string;

/**
 * Project-board asset directory. Defaults to a neutral folder; a host can point
 * it at its own deployment's directory by setting `__CAVI_PROJECT_BOARD_ASSET_DIR__`.
 */
export declare function getProjectBoardAssetDir(): string;

export declare function getRuntimeBasePath(): string;

export declare function getTeamLookupKeys(team: OperatorRegistryTeam): string[];

export declare const HERMES_KANBAN_BOARD_PATH: string;

export declare const HERMES_KANBAN_TASKS_PATH: string;

export declare const HERMES_WS_PATH: string;

export type HermesGatewayTargets = GatewayTargets;

export declare const HTTP_API_CLIENT_ENV_ALIASES: {
    readonly caviBaseUrl: readonly [
        "EXPO_PUBLIC_CAVI_API_BASE_URL",
        "EXPO_PUBLIC_CAVI_CONTROL_COMPAT_BASE_URL",
        "VITE_CAVI_API_BASE_URL"
    ];
    readonly caviAuthToken: readonly [
        "EXPO_PUBLIC_CAVI_API_AUTH_TOKEN",
        "EXPO_PUBLIC_GATEWAY_TOKEN",
        "VITE_CAVI_API_AUTH_TOKEN"
    ];
    readonly caviClientId: readonly [
        "EXPO_PUBLIC_CAVI_API_CLIENT_ID",
        "EXPO_PUBLIC_GATEWAY_CLIENT_ID",
        "VITE_CAVI_API_CLIENT_ID"
    ];
    readonly gatewayBaseUrl: readonly [
        "EXPO_PUBLIC_GATEWAY_API_BASE_URL",
        "VITE_GATEWAY_API_BASE_URL"
    ];
    readonly gatewayAuthToken: readonly [
        "EXPO_PUBLIC_GATEWAY_TOKEN",
        "EXPO_PUBLIC_GATEWAY_API_AUTH_TOKEN",
        "VITE_GATEWAY_API_AUTH_TOKEN"
    ];
    readonly gatewayClientId: readonly [
        "EXPO_PUBLIC_GATEWAY_CLIENT_ID",
        "EXPO_PUBLIC_GATEWAY_API_CLIENT_ID",
        "VITE_GATEWAY_API_CLIENT_ID"
    ];
    readonly libraryBaseUrl: readonly [
        "EXPO_PUBLIC_LIBRARY_API_BASE_URL",
        "EXPO_PUBLIC_CAVI_LIBRARY_API_BASE_URL",
        "VITE_LIBRARY_API_BASE_URL"
    ];
    readonly libraryAuthToken: readonly [
        "EXPO_PUBLIC_LIBRARY_API_AUTH_TOKEN",
        "EXPO_PUBLIC_GATEWAY_TOKEN",
        "VITE_LIBRARY_API_AUTH_TOKEN"
    ];
    readonly libraryClientId: readonly [
        "EXPO_PUBLIC_LIBRARY_API_CLIENT_ID",
        "EXPO_PUBLIC_GATEWAY_CLIENT_ID",
        "VITE_LIBRARY_API_CLIENT_ID"
    ];
};

export declare const HTTP_API_CLIENT_ENV_KEYS: {
    readonly caviBaseUrl: "CAVI_API_BASE_URL";
    readonly caviAuthToken: "CAVI_API_AUTH_TOKEN";
    readonly caviClientId: "CAVI_API_CLIENT_ID";
    readonly gatewayBaseUrl: "GATEWAY_API_BASE_URL";
    readonly gatewayAuthToken: "GATEWAY_API_AUTH_TOKEN";
    readonly gatewayClientId: "GATEWAY_API_CLIENT_ID";
    readonly libraryBaseUrl: "LIBRARY_API_BASE_URL";
    readonly libraryAuthToken: "LIBRARY_API_AUTH_TOKEN";
    readonly libraryClientId: "LIBRARY_API_CLIENT_ID";
};

export type HttpApiResolvedConfig = {
    cavi: HttpApiSurfaceConfig;
    gateway: HttpApiSurfaceConfig;
    library: HttpApiSurfaceConfig;
};

export declare const LIBRARY_API_BASE_PATH: "/library/api";

export declare const LIBRARY_API_ENDPOINTS: {
    readonly root: "/library/api";
    readonly search: "/library/api/search";
    readonly ingest: "/library/api/ingest";
    readonly documents: "/library/api/documents";
    readonly fleetStatus: "/library/api/fleet-status";
    readonly status: "/library/api/status";
    readonly inbox: "/library/api/inbox";
    readonly promotable: "/library/api/promotable";
    readonly reviewRequests: "/library/api/review-requests";
    readonly clip: "/library/api/clip";
    readonly clipHealth: "/library/api/clip/health";
    readonly clipSchema: "/library/api/clip/schema";
    readonly clipLogs: "/library/api/clip/logs";
    readonly document: (id: string) => string;
};

export declare const LIBRARY_CLIP_DEFAULT_TEAM = "library";

export declare const LIBRARY_CLIP_ENDPOINT: "/library/api/clip";

export declare const LIBRARY_CLIP_HEALTH_ENDPOINT: "/library/api/clip/health";

export declare const LIBRARY_CLIP_LOGS_ENDPOINT: "/library/api/clip/logs";

export declare const LIBRARY_CLIP_SCHEMA_ENDPOINT: "/library/api/clip/schema";

export declare const LIBRARY_CLIP_SOURCE_TAG = "caviclip";

export declare class LibraryApiClient extends BaseHttpApiClient {
    readonly endpoints: {
        readonly root: "/library/api";
        readonly search: "/library/api/search";
        readonly ingest: "/library/api/ingest";
        readonly documents: "/library/api/documents";
        readonly fleetStatus: "/library/api/fleet-status";
        readonly status: "/library/api/status";
        readonly inbox: "/library/api/inbox";
        readonly promotable: "/library/api/promotable";
        readonly reviewRequests: "/library/api/review-requests";
        readonly clip: "/library/api/clip";
        readonly clipHealth: "/library/api/clip/health";
        readonly clipSchema: "/library/api/clip/schema";
        readonly clipLogs: "/library/api/clip/logs";
        readonly document: (id: string) => string;
    };
    readonly request: HttpApiTransport;
    constructor(options: HttpApiClientOptions);
    ingest(body: LibraryIngestRequest, idempotencyKey?: string): Promise<LibraryIngestResult>;
    search<T = unknown>(query: Record<string, string | number | boolean | undefined>): Promise<T>;
    getDocument<T = unknown>(id: string): Promise<T>;
}

export type LibraryClipDiagnosticsCheck = {
    id: "clip-endpoint" | "pipeline-status" | "clip-health" | "clip-schema" | "clip-logs";
    label: string;
    path: string;
    ok: boolean;
    status?: number;
    message: string;
    source: "local-contract" | "gateway";
};

export type LibraryClipDiagnosticsLog = {
    at?: string;
    level?: string;
    message: string;
    path?: string;
};

export type LibraryClipDiagnosticsSnapshot = {
    fetchedAt: number;
    endpoint: typeof LIBRARY_CLIP_ENDPOINT;
    schema: LibraryClipSchemaSnapshot | Record<string, unknown>;
    schemaSource: "local-contract" | "gateway";
    checks: LibraryClipDiagnosticsCheck[];
    logs: LibraryClipDiagnosticsLog[];
};

export type LibraryClipInput = {
    title?: string | null;
    sourceUrl?: string | null;
    text?: string | null;
    team?: string | null;
    tags?: readonly string[] | null;
    note?: string | null;
    metadata?: Record<string, unknown> | null;
    capturedAt?: string | null;
};

export type LibraryClipRequest = {
    title: string;
    team: string;
    tags: string[];
    note: string;
    source_url?: string;
    text?: string;
    metadata: Record<string, unknown>;
};

export type LibraryClipResult = {
    accepted?: boolean;
    id?: string;
    clip_id?: string;
    jobId?: string;
    message?: string;
    errors?: Array<{
        field?: string;
        message: string;
    }>;
    [key: string]: unknown;
};

export type LibraryClipSchemaField = {
    type: string;
    required: boolean;
    description: string;
};

export type LibraryClipSchemaSnapshot = {
    contract: "LIBRARY_CLIP_V1";
    endpoint: typeof LIBRARY_CLIP_ENDPOINT;
    method: "POST";
    fields: Record<keyof LibraryClipRequest, LibraryClipSchemaField>;
    example: LibraryClipRequest;
};

export type LibraryClipTransport = <T>(path: string, init?: {
    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
    body?: unknown;
    timeoutMs?: number;
}) => Promise<T>;

export type LibraryIngestRequest = {
    source: LibraryIngestSource;
    workspaceId?: string;
    channelId?: string;
    threadId?: string;
    requestedBy?: string;
};

export type LibraryIngestResult = {
    accepted: boolean;
    id?: string;
    jobId?: string;
    message?: string;
    errors?: Array<{
        field?: string;
        message: string;
    }>;
};

export type LibraryIngestSource = {
    kind: "url" | "text" | "file" | "note";
    uri?: string;
    title?: string;
    text?: string;
    mimeType?: string;
    metadata?: Record<string, unknown>;
};

export type LibraryManualFileClipInput = {
    name: string;
    uri?: string | null;
    mimeType?: string | null;
    size?: number | null;
    text?: string | null;
    capturedAt?: string | null;
};

export type LibraryNote = {
    schema_version: number;
    id: string;
    note_type: LibraryNoteType;
    title: string;
    aliases: string[];
    tags: string[];
    domains: string[];
    summary: string;
    status: LibraryStatus;
    verification: LibraryVerification;
    language: string;
    sensitivity: LibrarySensitivity;
    compiled_at: string;
    compiled_by: string;
    content_hash: string;
    reviewed_at: string | null;
    reviewed_by: string | null;
    sources: LibrarySourceEntry[];
};

/** Fleet Library Schema v1 — team library status and candidate data for Cavi Control. */
export type LibraryNoteType = "concept" | "source" | "meeting" | "decision" | "transcript" | "synthesis" | "person" | "org" | "project";

export type LibrarySensitivity = "public" | "internal" | "confidential";

export type LibrarySourceEntry = {
    uri: string;
    title?: string;
    kind: "web" | "file" | "repo" | "meeting" | "chat" | "manual";
    format: "html" | "pdf" | "md" | "txt" | "audio" | "video" | "email" | "json";
    capture_method: "clip" | "upload" | "transcription" | "manual" | "agent";
    captured_at: string;
    author?: string;
    site?: string;
    published_at?: string;
};

export type LibraryStatus = "draft" | "active" | "archived";

export type LibraryVerification = "unreviewed" | "reviewed" | "disputed";

export declare function listCaviTeamPortalIds(): string[];

export declare function listCompiledCanonicalTeams(): OperatorRegistryTeam[];

export declare function listPortalLibraryRefs(): PortalLibraryRef[];

export declare function loadOperatorControlSection<TKey extends OperatorControlSectionKey, TData>(params: {
    key: TKey;
    run: () => Promise<TData>;
    fallback: () => TData;
    authoritative: boolean;
    sampleLimit: number | null;
    expectedContract: string;
    note: string;
}): Promise<OperatorSectionLoadResult<TKey, TData>>;

export declare function matchesOperatorTeamIdentifier(team: OperatorRegistryTeam, identifier: string | null | undefined): boolean;

export declare function matchesTaskTargetToTeam(target: {
    team_id?: string | null;
    team_slug?: string | null;
}, team: OperatorRegistryTeam): boolean;

export declare function matchesTeamIdentifier(team: OperatorRegistryTeam, identifier: string | null | undefined): boolean;

export declare const MOBILE_GATEWAY_ENDPOINT_CONTRACTS: {
    readonly providerConfig: {
        readonly surface: "provider-config";
        readonly path: "http-base + /v1/*, /health*; ws-base + /api/ws";
        readonly owner: "mobile gateway owner";
        readonly note: "Resolve explicit HTTP and WS targets from the saved gateway URL; preserve bearer auth.";
    };
    readonly preflightHealth: {
        readonly surface: "preflight-health";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "mobile gateway owner";
        readonly note: "Primary reachability check for the selected gateway API server.";
    };
    readonly preflightHealthDetailed: {
        readonly surface: "preflight-health-detailed";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "mobile gateway owner";
        readonly note: "Detailed health check; failures should be reported without hiding the basic health result.";
    };
    readonly preflightCapabilities: {
        readonly surface: "preflight-capabilities";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "mobile gateway owner";
        readonly note: "Authenticated API-server capability proof for saved bearer tokens.";
    };
    readonly websocketSession: {
        readonly surface: "websocket-session";
        readonly path: string;
        readonly owner: "mobile gateway owner";
        readonly note: "Dashboard/TUI JSON-RPC for chat, sessions, logs, and health/status.";
    };
    readonly gatewayMediaProviders: {
        readonly surface: "gateway-media-providers";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/media contract";
        readonly note: "Shared media provider inventory for audio, image, video, and music generation across gateways.";
    };
    readonly gatewayMediaAudio: {
        readonly surface: "gateway-media-audio";
        readonly method: "POST";
        readonly path: string;
        readonly owner: "gateway/media contract";
        readonly note: "Core audio generation route exposed through the provider-neutral media client.";
    };
    readonly gatewayMediaImage: {
        readonly surface: "gateway-media-image";
        readonly method: "POST";
        readonly path: string;
        readonly owner: "gateway/media contract";
        readonly note: "Core image generation route exposed through the provider-neutral media client.";
    };
    readonly gatewayMediaVideo: {
        readonly surface: "gateway-media-video";
        readonly method: "POST";
        readonly path: string;
        readonly owner: "gateway/media contract";
        readonly note: "Core video generation route exposed through the provider-neutral media client.";
    };
    readonly gatewayMediaMusic: {
        readonly surface: "gateway-media-music";
        readonly method: "POST";
        readonly path: string;
        readonly owner: "gateway/media contract";
        readonly note: "Core music generation route exposed through the provider-neutral media client.";
    };
    readonly gatewayMediaJob: {
        readonly surface: "gateway-media-job";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/media contract";
        readonly note: "Core media job status route used by audio, image, video, and music generation.";
    };
    readonly gatewayMediaAssets: {
        readonly surface: "gateway-media-assets";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/media contract";
        readonly note: "Core media asset inventory route.";
    };
    readonly gatewayMediaAsset: {
        readonly surface: "gateway-media-asset";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/media contract";
        readonly note: "Core media asset bytes and metadata route.";
    };
    readonly gatewayWikiVaults: {
        readonly surface: "gateway-wiki-vaults";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/wiki contract";
        readonly note: "Core wiki vault inventory for external Obsidian/QMD plugin vaults.";
    };
    readonly gatewayWikiTree: {
        readonly surface: "gateway-wiki-tree";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/wiki contract";
        readonly note: "Core wiki tree route.";
    };
    readonly gatewayWikiRead: {
        readonly surface: "gateway-wiki-read";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/wiki contract";
        readonly note: "Core wiki read route for QMD/Markdown pages.";
    };
    readonly gatewayWikiIngest: {
        readonly surface: "gateway-wiki-ingest";
        readonly method: "POST";
        readonly path: string;
        readonly owner: "gateway/wiki contract";
        readonly note: "Core wiki ingest route used by external wiki plugins.";
    };
    readonly gatewayWikiCompile: {
        readonly surface: "gateway-wiki-compile";
        readonly method: "POST";
        readonly path: string;
        readonly owner: "gateway/wiki contract";
        readonly note: "Core QMD compile route for wiki pages and collections.";
    };
    readonly gatewayWikiPromote: {
        readonly surface: "gateway-wiki-promote";
        readonly method: "POST";
        readonly path: string;
        readonly owner: "gateway/wiki contract";
        readonly note: "Core wiki promotion route for durable vault publishing.";
    };
    readonly costHistory: {
        readonly surface: "cost-history";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/cavi owner";
        readonly note: "CAVI cost history endpoint.";
    };
    readonly operatorStatus: {
        readonly surface: "operator-status";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/cavi owner";
        readonly note: "Operator-status endpoint used as an HTTP preflight fallback.";
    };
    readonly operatorSnapshot: {
        readonly surface: "operator-snapshot";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/cavi owner";
        readonly note: "CAVI Control operator aggregate snapshot for mobile and portal fallbacks.";
    };
    readonly operatorTaskDispatch: {
        readonly surface: "operator-task-dispatch";
        readonly method: "POST";
        readonly path: string;
        readonly owner: "ODB + gateway owner";
        readonly note: "OperatorTaskCreateRequest is accepted by the unified CAVI Control operator task endpoint.";
    };
    readonly kanbanTasks: {
        readonly surface: "kanban-tasks";
        readonly method: "POST";
        readonly path: string;
        readonly owner: "gateway/kanban owner";
        readonly note: "Kanban-native task creation remains a separate gateway surface from the CAVI Control operator task endpoint.";
    };
    readonly kanbanBoard: {
        readonly surface: "kanban-board";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/kanban owner";
        readonly note: "Unified Kanban board through bearer-authenticated /api/plugins/kanban/board for Project Board and Operator visibility.";
    };
    readonly teamWorkspace: {
        readonly surface: "team-workspace";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/team contract";
        readonly note: "Agnostic team-owned folder route; resolve the concrete path through the team manifest whitelist.";
    };
    readonly teamAgentWorkspace: {
        readonly surface: "team-agent-workspace";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "gateway/team contract";
        readonly note: "Agnostic agent-owned media/research folder route; resolve concrete paths through the team manifest whitelist.";
    };
    readonly fleetLibrary: {
        readonly surface: "fleet-library";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "library gateway owner";
        readonly note: "Base fleet snapshot; mobile enriches it with library status, inbox, promotable, and review-request paths when available.";
    };
    readonly libraryPipelineStatus: {
        readonly surface: "library-pipeline-status";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "library gateway owner";
        readonly note: "Library ingest pipeline counters used by the mobile forge and fleet summaries.";
    };
    readonly libraryPipelineInbox: {
        readonly surface: "library-pipeline-inbox";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "library gateway owner";
        readonly note: "Optional inbox item detail for assigning arrival pressure to library lanes.";
    };
    readonly libraryPromotable: {
        readonly surface: "library-promotable";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "library gateway owner";
        readonly note: "Promotable note rows used to hydrate the library board, promotions, and graph surfaces.";
    };
    readonly libraryReviewRequests: {
        readonly surface: "library-review-requests";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "library gateway owner";
        readonly note: "Review-request state joined onto promotable notes before mobile renders library operation rows.";
    };
    readonly vaultTree: {
        readonly surface: "vault-tree";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "vault/gateway owner";
        readonly note: "Obsidian vault tree route.";
    };
    readonly vaultRead: {
        readonly surface: "vault-read";
        readonly method: "GET";
        readonly path: string;
        readonly owner: "vault/gateway owner";
        readonly note: "Obsidian file read route.";
    };
};

export type MobileGatewayContractGap = {
    area: string;
    expectedContract: string;
    note: string;
    reason: "backend-not-configured" | "unknown";
};

export type MobileGatewayEndpointContract = {
    surface: string;
    method?: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
    path: string;
    owner: string;
    note: string;
};

export type MobileGatewaySurfaceKey = keyof typeof MOBILE_GATEWAY_ENDPOINT_CONTRACTS;

export declare function normalizeDiscourseEvent(raw: unknown, fallbackTaskId: string): DiscourseEvent | null;

export declare function normalizeEmailAddress(value: unknown): string | null;

export declare function normalizeEmailList(emails: string[]): string[];

export declare function normalizeLimitations(value: unknown): readonly string[];

export declare function normalizeProjectBoardBacklogItem(raw: unknown): ProjectBoardBacklogApiItemResponse | null;

export declare function normalizeProjectBoardPriority(value: unknown): ProjectBoardBacklogPriority;

export declare function normalizeProjectBoardStatus(value: unknown): ProjectBoardBacklogStatus;

export declare function normalizeProjectBoardStorageMode(value: unknown): ProjectBoardStorageMode;

export declare function normalizeSection(value: unknown): string;

export declare function normalizeSessionAgentId(value: string | null | undefined): string | null;

export declare function normalizeSessionKey(value: string | null | undefined): string | null;

export declare function normalizeTaskDiscourseSnapshot(raw: unknown, fallbackTaskId: string): TaskDiscourseSnapshot;

export declare function normalizeTeamLookupValue(value: string): string;

export declare function normalizeTeamRegistryTeam(team: TeamRegistryTeamConfig, fallback?: OperatorRegistryTeam | null): OperatorRegistryTeam;

export declare const OPERATOR_DISPATCH_ENDPOINTS: {
    readonly message: "/api/message";
    readonly operatorEvents: "/operator/events";
    readonly taskReceiptsTemplate: "/cavi-control/api/tasks/{taskId}/receipts";
};

export declare const OPERATOR_MEMORY_SAMPLE_LIMIT = 20;

export declare const OPERATOR_TASK_SAMPLE_LIMIT = 20;

export declare const OPERATOR_WORKER_TASK_SAMPLE_LIMIT = 20;

export declare function operatorControlExpectedContractSummary(): string;

export type OperatorControlSectionKey = "status" | "registryDetail" | "tasks" | "memory" | "workerReady" | "workerTasks";

export type OperatorControlSectionStatus = {
    available: boolean;
    authoritative: boolean;
    error: string | null;
    sampleLimit: number | null;
};

export type OperatorControlSnapshot = {
    status: OperatorControlStatusSnapshot;
    registryDetail: OperatorRegistrySnapshot;
    tasks: OperatorTaskListSnapshot;
    memory: OperatorSharedMemorySnapshot;
    workerReady: OperatorWorkerReadySnapshot;
    workerTasks: OperatorWorkerTaskListSnapshot;
    sectionStatus: Record<OperatorControlSectionKey, OperatorControlSectionStatus>;
};

export type OperatorControlStatusSnapshot = {
    primaryOperator: string;
    fallbackOperator: string;
    authorityMode: "authoritative-failover";
    taskStorePath: string;
    registry: {
        agentCount: number;
        teamCount: number;
        sourcePath: string;
        sourceHash: string;
        generatedAt: number;
    };
    taskSummary: {
        primaryOperator: string;
        fallbackOperator: string;
        authorityMode?: "authoritative-failover";
        tasks: Record<OperatorTaskState, number>;
        totals: {
            total: number;
            terminal: number;
            active: number;
        };
    };
    runtimes: {
        acpBackendId: string | null;
        acpBackendHealthy: boolean;
        sharedMemoryAuthority: OperatorSharedMemoryAuthority;
    };
    sharedMemory: {
        storePath: string;
        collections: Record<OperatorSharedMemoryCollection, OperatorMemoryCollectionSummary>;
    };
    legacyWorkerFleet: OperatorWorkerTransportSnapshot;
    delegatedFirstClassAgents: OperatorDelegatedTransportSnapshot;
    worker: OperatorWorkerTransportSnapshot;
    mesh: {
        legacyExecutionFleet: OperatorWorkerTransportSnapshot;
        delegatedFirstClassAgents: OperatorDelegatedTransportSnapshot;
        executionFleet: OperatorWorkerTransportSnapshot;
        projectOps: {
            mode: "task-lifecycle";
            configured: boolean;
            baseUrl: string | null;
            eventEndpoint: string | null;
            authScheme: "bearer" | null;
            authEnv: string | null;
            authConfigured: boolean;
        };
        domainOrchestrators: OperatorDelegatedTransportSnapshot;
        marketing: OperatorDelegatedTransportSnapshot;
        research: OperatorDelegatedTransportSnapshot;
    };
};

export type OperatorDelegatedTransportSnapshot = {
    dispatchTransport: "delegated-http";
    transportAliases: string[];
    role: "delegated-first-class-agent-boundary";
    configured: boolean;
    baseUrl: string | null;
    authScheme: "bearer" | null;
    authEnv: string | null;
    authConfigured: boolean;
    globalDefaultAlias: string | null;
    servedTeams: string[];
    leadAliases: string[];
    defaultAliasByTeam: Record<string, string>;
    teamTopology: Array<{
        teamId: string;
        declaredTransport: string | null;
        resolvedTransport: "delegated-http";
        leadAlias: string | null;
        defaultAlias: string | null;
        dispatchEndpointEnv: string | null;
        dispatchPath: string | null;
        dispatchAuthEnv: string | null;
        resolvedBaseUrl: string | null;
        resolvedEndpoint: string | null;
        authConfigured: boolean;
        /** When resolvedBaseUrl is null: which env vars to set on the gateway (no secret values). */
        urlResolutionHint?: string | null;
    }>;
    legacyTeams: string[];
};

export type OperatorMemoryCollectionSummary = {
    count: number;
    lastVerifiedAt: number | null;
    writeMode: "append-only" | "upsert";
};

export type OperatorMemoryRecord = {
    collection: OperatorSharedMemoryCollection;
    recordId: string;
    scopeKey: string;
    summary: string | null;
    content: Record<string, unknown>;
    metadata: {
        source: string;
        writer: string;
        evidence_ref: string;
        verified_at: number;
        ttl_policy?: string;
    };
    promotedAt: number;
};

export type OperatorRegistryAgent = {
    id: string;
    name: string;
    role: string | null;
    specialty: string | null;
    model: string | null;
    skill: string | null;
    spawnTemplate: string | null;
    repos: string[];
    repoConfig: OperatorRegistryAgentRepoConfig | null;
    triggers: string[];
    notes: string | null;
    teams: string[];
    maxConcurrentSessions: number;
    capabilities: string[];
    mcpAccess: string[];
    reviewHandles: string[];
    executionMode: string | null;
    identity: OperatorRegistryAgentIdentity | null;
    ownership: OperatorRegistryAgentOwnership | null;
    roleBoundary: OperatorRegistryAgentRoleBoundary | null;
    tokenEnv: string | null;
    boardUrl: string | null;
    k8sService: string | null;
    delegatesTo: string[];
};

export type OperatorRegistryAgentIdentity = {
    theme: string | null;
    avatar: string | null;
    rosterImage: string | null;
    cardImage: string | null;
    alt: string | null;
};

export type OperatorRegistryAgentOwnership = {
    parentOrchestrator: string | null;
    ownsDomains: string[];
    delegatesTo: string[];
    ownsOutputs: string[];
    runtimeSpecialists: string[];
};

export type OperatorRegistryAgentRepoConfig = {
    mode: "auto" | "manual" | "all";
    include: string[];
    exclude: string[];
    patterns: string[];
};

export type OperatorRegistryAgentRoleBoundary = {
    allowed: string[];
    forbidden: string[];
    enforcement: string | null;
};

export type OperatorRegistryDelegatedTransportConfig = {
    globalDefaultAlias: string | null;
};

export type OperatorRegistryIdentity = {
    id: string;
    kind: "agent" | "runtime";
    name: string;
    role: string | null;
    capabilities: string[];
    teamIds: string[];
    leadTeamIds: string[];
    maxConcurrentSessions: number;
};

export type OperatorRegistryRuntime = {
    id: string;
    name: string | null;
    role: string | null;
    namespace: string | null;
    status: string | null;
    triggers: string[];
    maxConcurrentSessions: number;
    port: number | null;
    replicas: number | null;
    endpoints: string[];
    discordBotId: string | null;
};

export type OperatorRegistryRuntimeConfig = {
    transports: {
        delegatedHttp: OperatorRegistryDelegatedTransportConfig;
    };
};

export type OperatorRegistrySkillOwnership = {
    skill: string;
    owner: string;
    status: string | null;
};

export type OperatorRegistrySnapshot = {
    schema: "OperatorAgentRegistryV1" | "OperatorAgentRegistryV2";
    generatedAt: number;
    sourcePath: string;
    sourceHash: string;
    agentCount: number;
    teamCount: number;
    operatorRuntime: OperatorRegistryRuntimeConfig;
    agents: OperatorRegistryAgent[];
    teams: OperatorRegistryTeam[];
    k8sCluster: OperatorRegistryRuntime[];
    identities: OperatorRegistryIdentity[];
    skillOwnership: OperatorRegistrySkillOwnership[];
};

export type OperatorRegistryTeam = {
    id: string;
    name: string;
    teamSlug: string;
    teamCode: string;
    sectorSlug: string;
    sectorCode: string;
    portalId: string | null;
    displayName: string;
    legacyAliases: string[];
    department: string | null;
    /** Deprecated; retained for compatibility while gateway transitions to `department`. */
    kind: string | null;
    parentTeamId: string | null;
    lead: string | null;
    leadKind: "agent" | "runtime" | "external" | null;
    routeViaLead: boolean;
    mission: string | null;
    members: string[];
    runtimeIds: string[];
    memberIdentityIds: string[];
    ownsCapabilities: string[];
    maxParallel: number | null;
    dispatchTransport: string | null;
    dispatchEndpointEnv: string | null;
    dispatchPath: string | null;
    dispatchAuthScheme: string | null;
    dispatchAuthEnv: string | null;
    dispatchDefaultAlias: string | null;
    routingPolicy: string | null;
    notes: string | null;
    ancestorTeamIds: string[];
    descendantTeamIds: string[];
    teamManifest: string | null;
    headOwnedAliases: string[];
    runtimeMembers: string[];
};

export type OperatorSectionLoadResult<TKey extends OperatorControlSectionKey, TData> = {
    key: TKey;
    data: TData;
    status: OperatorControlSnapshot["sectionStatus"][TKey];
    contractGap: ContractGap | null;
};

export type OperatorSharedMemoryAuthority = "qdrant" | "vector-memory" | "local-json-shim";

export type OperatorSharedMemoryCollection = "service-context" | "task-outcomes" | "contract-registry" | "channel-events";

export type OperatorSharedMemorySnapshot = {
    authority: OperatorSharedMemoryAuthority;
    storePath: string;
    generatedAt: number;
    collections: Record<OperatorSharedMemoryCollection, OperatorMemoryCollectionSummary>;
    records: OperatorMemoryRecord[];
};

export declare function operatorTaskDiscoursePath(taskId: string): string;

export declare function operatorTaskDiscoursePluginAliasPath(taskId: string): string;

export type OperatorTaskDispatchMode = "operator-task" | "kanban-native";

export type OperatorTaskListSnapshot = {
    tasks: OperatorTaskRecord[];
    summary: Record<OperatorTaskState, number>;
};

export type OperatorTaskRecord = {
    envelope: {
        task_id: string;
        parent_task_id?: string | null;
        requester: {
            id: string;
            kind: string;
        };
        target: {
            capability: string;
            team_id?: string | null;
            team_slug?: string | null;
            alias?: string | null;
        };
        objective: string;
        tier: OperatorTaskTier;
        acceptance_criteria: string[];
        timeout_s: number;
    };
    receipt: {
        task_id: string;
        run_id: string;
        state: OperatorTaskState;
        owner?: string | null;
        attempt: number;
        created_at: number;
        updated_at: number;
        queue_latency_ms?: number | null;
        artifacts: string[];
        failure_code?: string | null;
    };
    events: Array<{
        id: string;
        at: number;
        state: OperatorTaskState;
        note?: string | null;
        owner?: string | null;
        failureCode?: string | null;
    }>;
    validation: {
        validation_id: string;
        validator: string;
        result: "passed" | "failed" | "waived" | "pending";
    } | null;
    outcome: {
        outcome: "success" | "partial" | "fail" | "blocked";
        verification_status: "passed" | "failed" | "waived" | "pending";
        rework_needed: boolean;
        recorded_at: number;
    } | null;
};

export type OperatorTaskState = "accepted" | "queued" | "started" | "retrying" | "blocked" | "completed" | "dead-letter";

export type OperatorTaskTier = "LITE" | "STANDARD" | "HEAVY";

export type OperatorWorkerReadySnapshot = {
    status: "ok" | "not-ready";
    pending: number;
    active: number;
    shuttingDown: boolean;
    auth: {
        enabled: boolean;
        scheme: "bearer" | "none";
    };
    backend: {
        mode: "memory" | "filesystem" | "redis";
        persistenceEnabled: boolean;
        stateFile: string | null;
        recoveredTasks: number;
    };
};

export type OperatorWorkerTaskListSnapshot = {
    tasks: OperatorWorkerTaskRecord[];
    stats: {
        pending: number;
        active: number;
        shuttingDown: boolean;
    };
};

export type OperatorWorkerTaskRecord = {
    taskId: string;
    runId: string;
    type: string;
    priority: "low" | "normal" | "high";
    state: OperatorWorkerTaskState;
    attempt: number;
    createdAt: number;
    updatedAt: number;
    startedAt?: number;
    finishedAt?: number;
    callbackUrl?: string;
    summary?: string;
    failureCode?: string;
    output?: Record<string, unknown>;
    metadata?: Record<string, unknown>;
};

export type OperatorWorkerTaskState = "accepted" | "queued" | "started" | "retrying" | "completed" | "dead-letter";

export type OperatorWorkerTransportSnapshot = {
    dispatchTransport: string;
    role: "legacy-worker-fleet";
    configured: boolean;
    baseUrl: string | null;
    receiptTemplate: string | null;
    authScheme: "bearer" | null;
    authEnv: string | null;
    authConfigured: boolean;
};

export type OperatorWorkflowLane = {
    teamId: string;
    teamName: string;
    department: string | null;
    /** Deprecated; retained for compatibility while gateway transitions to `department`. */
    teamKind: string | null;
    runtimeIds: string[];
    runtimeName: string | null;
    runtimeRole: string | null;
    leadName: string | null;
    leadRole: string | null;
    transport: string;
    endpoint: string | null;
    authScheme: string | null;
    authEnv: string | null;
    configured: boolean;
    authConfigured: boolean;
    dispatchReady: boolean;
    status: OperatorWorkflowLaneStatus;
    /** Human-readable reason for degraded/unconfigured, or operational note for ready manual/local lanes */
    statusDetail: string | null;
    routingPolicy: string | null;
    tasksTotal: number;
    tasksCompleted: number;
    tasksBlocked: number;
    tasksFailed: number;
    tasksDeadLetter: number;
    tasksTimeout: number;
    successRate: number;
    failureRate: number;
    avgTimeToCompleteMs: number | null;
    runsTotal: number;
    totalTokens: number;
    totalCostUsd: number;
    primaryModel?: string;
    lastActivityAt: number | null;
    queue: {
        pending: number;
        active: number;
        recovered: number;
        backendMode: "memory" | "filesystem" | "redis";
    } | null;
};

export type OperatorWorkflowLaneStatus = "ready" | "degraded" | "unconfigured";

export declare function parseAgentSessionKey(sessionKey: string | null | undefined): ParsedAgentSessionKey | null;

export type ParsedAgentSessionKey = {
    agentId: string;
    rest: string;
};

export declare function parseProjectBoardCallAck(raw: unknown, fallback: {
    action: string;
    requestedBy: string;
    traceId: string;
}): ProjectBoardCallResult;

export declare const PORTAL_CLIENT_ID_HEADER: "X-Portal-Client-Id";

export declare const PORTAL_MEMORY_SNAPSHOT_CONTRACT: "PORTAL_MEMORY_SNAPSHOT_V1";

export declare class PortalApiClient extends BaseHttpApiClient {
    readonly portalId: string;
    readonly request: HttpApiTransport;
    constructor(options: PortalApiClientOptions);
    protected portalPath(path: string): string;
    getDashboard<T = unknown>(): Promise<T>;
    getFromPortal<T = unknown>(relativePath: string): Promise<T>;
    postToPortal<T = unknown>(relativePath: string, body: unknown, idempotencyKey?: string): Promise<T>;
    getPortalMemorySnapshot<T = unknown>(teamSlug: string, memberId: string, memoryKey: string): Promise<T>;
}

export type PortalApiClientOptions = HttpApiClientOptions & {
    portalId: string;
};

export type PortalApiEnvelopeBase = {
    clientId: string;
    portalId: string;
    teamSlug: string;
    memberId?: string;
    feature: string;
    library?: PortalLibraryRef;
};

export type PortalApiError = {
    code: string;
    message: string;
    details?: Record<string, unknown>;
};

export type PortalApiRequestEnvelope<TContract extends string, TPayload> = PortalApiEnvelopeBase & {
    contract: TContract;
    requestedAt: number;
    payload: TPayload;
};

export type PortalApiResponseEnvelope<TContract extends string, TData> = PortalApiEnvelopeBase & {
    contract: TContract;
    generatedAt: number;
    ok: boolean;
    data: TData;
    error?: PortalApiError;
};

/**
 * Generic portal dashboard route for any portal slug. The slug is supplied at
 * runtime (from the team manifest) — the package bakes in no portal/agent roster.
 */
export declare function portalDashboardPath(portalId: string): string;

export type PortalLibraryRef = {
    scope: "team" | "fleet";
    libraryTeamId: string;
    ownerPortalId?: string;
};

export type PortalMemoryEnvelope<TSchemaContract extends string, TPayload> = {
    contract: typeof PORTAL_MEMORY_SNAPSHOT_CONTRACT;
    clientId: string;
    teamSlug: string;
    memberId: string;
    memoryKey: string;
    schemaContract: TSchemaContract;
    updatedAt: number;
    payload: TPayload;
    portalId?: string;
    feature?: string;
    library?: PortalLibraryRef;
};

export type PortalTtsAgentVoiceAssignment = {
    agentKey: string;
    voiceValue: string;
    voiceId: string;
    voiceLabel: string;
    providerId?: string;
    providerLabel?: string;
    assignedAt: string;
};

export type PortalTtsAudioRequest = {
    text: string;
    voiceId?: string | null;
    providerId?: string | null;
    format?: string | null;
    accept?: string | null;
    options?: Record<string, GatewayMediaJsonValue>;
};

export type PortalTtsAudioTransport = {
    requestBlob: PortalTtsBlobRequester;
};

export type PortalTtsBlobRequester = (path: string, init?: Pick<HttpApiRequestInit, "body" | "headers" | "method">) => Promise<Blob>;

export type PortalTtsDashboardVoiceLike = {
    current_voice_id?: string;
    currentVoiceId?: string;
    current_voice_name?: string;
    currentVoiceName?: string;
    target_voice?: string;
    targetVoice?: string;
};

export type PortalTtsJsonRequester = <T>(path: string) => Promise<T>;

export type PortalTtsProviderLike = {
    id: string;
    label?: string;
    name?: string;
    configured?: boolean;
    voices?: readonly (PortalTtsProviderVoiceLike | string)[];
};

export type PortalTtsProviderVoiceLike = {
    id: string;
    name?: string;
};

export type PortalTtsVoiceOption = {
    value: string;
    label: string;
    detail?: string;
    source: "gateway" | "dashboard";
    voiceId: string;
    providerId?: string;
    providerLabel?: string;
    agentKey?: string;
};

export declare function postLibraryClip<T extends LibraryClipResult = LibraryClipResult>(requestJson: LibraryClipTransport, input: LibraryClipInput, opts?: {
    timeoutMs?: number;
}): Promise<T>;

export declare const PROJECT_BOARD_CANONICAL_AVATAR_CANDIDATES: readonly [
    string,
    string,
    string
];

export declare const PROJECT_BOARD_FALLBACK_LIMITATIONS: readonly [
    "Cavi Control adapter used compatibility projection for Project Board payload."
];

export type ProjectBoardBacklogApiItemResponse = {
    id: string;
    title: string;
    description: string | null;
    section: string;
    priority: ProjectBoardBacklogPriority;
    status: ProjectBoardBacklogStatus;
    tags: string[];
    createdAt: number;
    updatedAt: number;
};

export type ProjectBoardBacklogApiResponse = {
    sections: Array<{
        section: string;
        items: ProjectBoardBacklogApiItemResponse[];
    }>;
    priorities: Record<ProjectBoardBacklogPriority, number>;
    statusCounters: Record<ProjectBoardBacklogStatus, number>;
    totalItems: number;
    lastUpdated: number;
    storage: ProjectBoardStorageMode;
    limitations: readonly string[];
};

export type ProjectBoardBacklogDraft = {
    title: string;
    description: string;
    section: string;
    priority: ProjectBoardBacklogPriority;
    status: ProjectBoardBacklogStatus;
    tags: string[];
};

export type ProjectBoardBacklogItem = {
    id: string;
    title: string;
    description: string | null;
    section: string;
    priority: ProjectBoardBacklogPriority;
    status: ProjectBoardBacklogStatus;
    tags: string[];
    createdAt: number;
    updatedAt: number;
};

export declare function projectBoardBacklogItemPath(itemId: string): string;

export type ProjectBoardBacklogMutationPayload = {
    title: string;
    description: string | null;
    section: string;
    priority: ProjectBoardBacklogPriority;
    status: ProjectBoardBacklogStatus;
    tags: string[];
};

export type ProjectBoardBacklogPriority = "p0" | "p1" | "p2" | "p3";

export type ProjectBoardBacklogSnapshot = {
    sections: Array<{
        section: string;
        items: ProjectBoardBacklogItem[];
    }>;
    priorities: Record<ProjectBoardBacklogPriority, number>;
    statusCounters: Record<ProjectBoardBacklogStatus, number>;
    totalItems: number;
    lastUpdated: number;
    storage: ProjectBoardStorageMode;
    limitations: readonly string[];
};

export type ProjectBoardBacklogStatus = "todo" | "in_progress" | "blocked" | "done";

export type ProjectBoardCallApiAckResponse = {
    ackId: string;
    status: "queued";
    action: string;
    requestedBy: string;
    queuedAt: number;
    queueDepth: number;
    note: string;
    storage: ProjectBoardStorageMode;
    limitations: readonly string[];
};

export type ProjectBoardCallRequest = {
    action: string;
    requestedBy: string;
    metadata: Record<string, string | number | boolean | null>;
};

export type ProjectBoardCallResult = {
    ackId: string;
    status: "queued";
    action: string;
    requestedBy: string;
    queuedAt: number;
    queueDepth: number;
    note: string;
    storage: ProjectBoardStorageMode;
    limitations: readonly string[];
    traceId: string;
};

export declare function projectBoardDraftToWorkboardCreate(params: {
    title: string;
    description: string | null;
    section: string;
    priority: ProjectBoardBacklogPriority;
    status: ProjectBoardBacklogStatus;
    tags: string[];
}): Record<string, unknown>;

export declare function projectBoardDraftToWorkboardPatch(params: {
    title: string;
    description: string | null;
    section: string;
    priority: ProjectBoardBacklogPriority;
    tags: string[];
}): Record<string, unknown>;

export type ProjectBoardEmailDraft = {
    email: string;
};

export type ProjectBoardEmailRecipient = {
    id: string;
    email: string;
};

export type ProjectBoardLiveHelpers = {
    workboardRpc?: OpenClawWorkboardRpc | null;
    loadProjectBoardWorkspaceLive: () => Promise<ProjectBoardWorkspaceSnapshot>;
    loadProjectBoardProfileForEmailMutation: () => Promise<ProjectBoardProfile>;
    persistProjectBoardEmails: (emails: string[]) => Promise<ProjectBoardProfile>;
    toBacklogMutationPayload: (draft: ProjectBoardBacklogDraft) => ProjectBoardBacklogMutationPayload;
};

export type ProjectBoardMutations = {
    createProjectBoardEmail: (draft: ProjectBoardEmailDraft) => Promise<MutationResult<{
        id: string;
        email: string;
    }>>;
    updateProjectBoardEmail: (emailId: string, draft: ProjectBoardEmailDraft) => Promise<MutationResult<{
        id: string;
        email: string;
    }>>;
    removeProjectBoardEmail: (emailId: string) => Promise<MutationResult<{
        id: string;
    }>>;
    createProjectBoardBacklogItem: (draft: ProjectBoardBacklogDraft) => Promise<MutationResult<ProjectBoardBacklogItem>>;
    updateProjectBoardBacklogItem: (itemId: string, draft: ProjectBoardBacklogDraft) => Promise<MutationResult<ProjectBoardBacklogItem>>;
    callProjectBoard: (request: ProjectBoardCallRequest) => Promise<MutationResult<ProjectBoardCallResult>>;
};

export declare function projectBoardPriorityToWorkboard(priority: ProjectBoardBacklogPriority): OpenClawWorkboardPriority;

export type ProjectBoardProfile = {
    name: string;
    role: string;
    photoPath: string | null;
    photoUrl: string | null;
    avatarCandidates: string[];
    emails: string[];
    lastUpdated: number;
    storage: ProjectBoardStorageMode;
    limitations: readonly string[];
};

export type ProjectBoardProfileApiResponse = {
    name: string;
    role: string;
    photoPath: string | null;
    photoUrl: string | null;
    emails: string[];
    lastUpdated: number;
    storage: ProjectBoardStorageMode;
    limitations: readonly string[];
};

export type ProjectBoardSprintApiResponse = {
    sprint: {
        id: string;
        name: string;
        goal: string;
        startsOn: string | null;
        endsOn: string | null;
    };
    statusMetrics: {
        total: number;
        todo: number;
        inProgress: number;
        blocked: number;
        done: number;
        completionRate: number;
    };
    lastUpdated: number;
    storage: ProjectBoardStorageMode;
    limitations: readonly string[];
};

export type ProjectBoardSprintStatus = {
    sprint: {
        id: string;
        name: string;
        goal: string;
        startsOn: string | null;
        endsOn: string | null;
    };
    statusMetrics: {
        total: number;
        todo: number;
        inProgress: number;
        blocked: number;
        done: number;
        completionRate: number;
    };
    lastUpdated: number;
    storage: ProjectBoardStorageMode;
    limitations: readonly string[];
};

export declare function projectBoardStatusToWorkboard(status: ProjectBoardBacklogStatus): OpenClawWorkboardStatus;

export type ProjectBoardStorageMode = "json-file" | "sqlite";

/** Operator-facing hint when Project Board workspace load fails (keep in sync with Project Board adapters). */
export declare function projectBoardWorkspaceDiagnosticRouteHint(): string;

export declare function projectBoardWorkspaceExpectedContractSummary(): string;

export type ProjectBoardWorkspaceSnapshot = {
    profile: ProjectBoardProfile;
    emails: ProjectBoardEmailRecipient[];
    sprint: ProjectBoardSprintStatus;
    backlog: ProjectBoardBacklogSnapshot;
};

export declare function requestLibraryClipDiagnostics(requestJson: LibraryClipTransport): Promise<LibraryClipDiagnosticsSnapshot>;

export declare function requestPortalTtsAudio(transport: PortalTtsAudioTransport, ttsPath: string, body: PortalTtsAudioRequest): Promise<Blob>;

export declare function requestPortalTtsProviders(requestJson: PortalTtsJsonRequester, providersPath: string): Promise<unknown>;

export declare function resetCanonicalOperatorRegistry(): void;

export declare function resetTeamRegistryConfig(): void;

export declare const resolveCaviPath: import("../../../index.js").SurfacePathResolver;

export declare function resolveCompiledCanonicalTeam(identifier: string | null | undefined): OperatorRegistryTeam | null;

export declare function resolveGatewayHttpBase(gatewayBaseUrl: string): string;

export declare function resolveGatewayHttpUrl(gatewayBaseUrl: string, pathname: string): string;

export declare function resolveGatewayWsUrl(gatewayBaseUrl: string): string;

export declare function resolveHttpApiConfigFromEnv(env: HttpApiEnvSource, options?: ResolveHttpApiConfigOptions): HttpApiResolvedConfig;

export type ResolveHttpApiConfigOptions = {
    defaults?: Partial<HttpApiResolvedConfig>;
    trimValues?: boolean;
    includeAliases?: boolean;
};

export declare function resolveLibraryApiPath(path: string): string;

export declare function resolveLibraryRefByTeamIdentity(value: string | null | undefined): PortalLibraryRef | null;

/**
 * Resolve a harness-native agent/team name to its canonical memory scope:
 *   - matches a member → `{ domain: team.id, member: member.id }`
 *   - matches a team   → `{ domain: team.id }`
 *   - no match         → `undefined` (caller skips that name)
 *
 * Member matches win over team matches (more specific). Matching is case-insensitive across
 * the canonical id plus the identity's slug/name/displayName/code/aliases.
 */
export declare function resolveMemoryScope(manifest: TeamManifest, name: string): MemoryScope | undefined;

export declare function resolveOperatorTaskDispatchContract(mode: OperatorTaskDispatchMode): MobileGatewayEndpointContract;

export declare function resolveOperatorTaskDispatchPath(mode?: OperatorTaskDispatchMode): string;

export declare const resolvePath: import("../../../index.js").SurfacePathResolver;

export declare function resolvePortalApiPath(portalId: string, relativePath: string): string;

export declare function resolvePortalLibraryRef(portalId: string): PortalLibraryRef | null;

export declare function resolvePortalPrimarySessionKey(params: {
    portalId: CaviTeamPortalId;
    suffix?: string | null;
}): string | null;

export declare function resolveProjectBoardAssetPath(fileName: string): string;

/** Static files under `public/` (`/agents`, `/angels`, …) for Vite `base` deployments. */
export declare function resolvePublicAsset(pathname: string): string;

export declare function resolveSessionApiPath(pathname: string): string;

export declare function resolveTeamFromCollection(teams: readonly OperatorRegistryTeam[], identifier: string | null | undefined): OperatorRegistryTeam | null;

export declare function resolveTeamSessionAgentId(params: {
    teamId?: string | null;
    operatorTeamId?: string | null;
    operatorTeamSlug?: string | null;
    agentAlias?: string | null;
}): string | null;

export declare function resolveTeamSessionKey(params: {
    teamId?: string | null;
    operatorTeamId?: string | null;
    operatorTeamSlug?: string | null;
    agentAlias?: string | null;
    suffix?: string | null;
}): string | null;

export type RunTaskLinkCandidate = {
    runKey: string;
    taskId: string | null;
};

export declare function sessionKeysEqual(left: string | null | undefined, right: string | null | undefined): boolean;

export declare function sortBacklogItems(items: ProjectBoardBacklogApiItemResponse[]): ProjectBoardBacklogApiItemResponse[];

export declare const SURFACE_CONTRACTS: Record<string, SurfaceContract>;

export type SurfaceContract = {
    key: string;
    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
    path: (params?: Record<string, string>) => string;
    degradation: "hard" | "gap" | "silent";
    owner: string;
    note: string;
};

export type TaskDiscourseAgent = {
    agentId: string;
    role: string;
    eventCount: number;
    tokensUsed: number;
    costUsd: number;
};

export declare function taskDiscourseExpectedContractSummary(): string;

export type TaskDiscourseSnapshot = {
    rootTaskId: string;
    agents: TaskDiscourseAgent[];
    events: DiscourseEvent[];
    delegationTree: DelegationNode[];
    summary: TaskDiscourseSummary;
};

export type TaskDiscourseSummary = {
    totalAgents: number;
    totalEvents: number;
    totalTokens: number;
    totalCostUsd: number;
    durationMs: number | null;
    blockerCount: number;
    decisionCount: number;
    outcome: "success" | "partial" | "fail" | "blocked" | "pending";
};

export type TaskObservabilitySummary = {
    taskId: string;
    taskState: OperatorTaskState | null;
    taskObjective: string | null;
    taskOwner: string | null;
    teamId: string | null;
    verification: string | null;
    primaryRunKey: string | null;
    runStatus: AgentRunStatus | null;
    runUpdatedAt: number | null;
    totalTokens: number | null;
    totalCostUsd: number | null;
    errorCount: number;
    model: string | null;
    provider: string | null;
    degraded: boolean;
    discourseTaskId: string;
};

export declare const TEAM_REGISTRY_CONFIG: TeamRegistryConfig;

export type TeamLibraryStatus = {
    teamId: string;
    teamName: string;
    lead: string;
    inboxCount: number;
    candidatesCount: number;
    promotedCount: number;
    rejectedCount: number;
    recentPromotions: Array<{
        id: string;
        title: string;
        note_type: LibraryNoteType;
        promoted_at: string;
        promoted_by: string;
        /** When set, mobile/web can open this path in the gateway wiki vault reader. */
        wiki_path?: string;
    }>;
    qmdHealth: {
        lastIndexedAt: number | null;
        collectionSize: number;
        healthy: boolean;
    };
};

export interface TeamRegistry {
    readonly provider: TeamRegistryProviderKind;
    listTeams(): OperatorRegistryTeam[];
    listPortalIds(): string[];
    getTeamLookupKeys(team: OperatorRegistryTeam): string[];
    resolveTeam(identifier: string | null | undefined): OperatorRegistryTeam | null;
    requireTeam(identifier: string | null | undefined): OperatorRegistryTeam;
    getPortalTeam(portalId: string | null | undefined): OperatorRegistryTeam;
    getPortalTeamCode(portalId: string | null | undefined): string;
    getPortalTeamSlug(portalId: string | null | undefined): string;
    getPortalTeamSectorSlug(portalId: string | null | undefined): string;
    getFleetLibraryRef(): PortalLibraryRef | null;
    resolvePortalLibraryRef(portalId: string | null | undefined): PortalLibraryRef | null;
    resolveLibraryRefByTeamIdentity(value: string | null | undefined): PortalLibraryRef | null;
    listLibraryRefs(): PortalLibraryRef[];
}

export type TeamRegistryConfig = {
    provider?: TeamRegistryProviderKind | null;
    manifest?: Partial<TeamManifest> | null;
    teams?: readonly TeamRegistryTeamConfig[] | null;
    libraries?: TeamRegistryLibraryConfig | null;
    snapshot?: Pick<OperatorRegistrySnapshot, "teams"> | null;
};

export type TeamRegistryLibraryConfig = {
    fleet?: TeamRegistryLibraryRefConfig | null;
    teams?: readonly TeamRegistryLibraryRefConfig[] | null;
};

export type TeamRegistryLibraryRefConfig = PortalLibraryRef & {
    lookupKeys?: readonly string[];
};

export type TeamRegistryProviderKind = "gateway" | "hermes" | "openclaw" | (string & {});

export type TeamRegistryTeamConfig = Partial<OperatorRegistryTeam> & {
    id: string;
    name?: string | null;
};

export declare function toProjectBoardProfile(raw: unknown): ProjectBoardProfile;

export declare function toProjectBoardWorkspaceFromCompatPayload(raw: unknown): ProjectBoardWorkspaceSnapshot;

export declare function toProjectBoardWorkspaceSnapshot(params: {
    profilePayload: unknown;
    sprintPayload: unknown;
    backlogPayload: unknown;
}): ProjectBoardWorkspaceSnapshot;

/**
 * Augment a base provider/gateway capabilities object with the CAVI Control
 * operator plane (status / snapshot / tasks endpoints + operator RPC methods).
 *
 * This is **plugin-gated**: the operator plane only exists when the cavi-control
 * plugin is installed on the target harness (the same cavi-control plugin runs on
 * OpenClaw and Hermes). It deliberately lives in `extensions/cavi`, not
 * in any provider, so the base OpenClaw/Hermes clients never assume a CAVI plugin
 * is present. A consumer that runs the plugin composes the operator surface on
 * top of the harness-native capabilities here.
 *
 * Provider-agnostic by design — pass any `GatewayCapabilities` (OpenClaw, Hermes,
 * or another harness) and get the same operator augmentation.
 */
export declare function withCaviControlOperatorCapabilities<T extends GatewayCapabilities & {
    rpcMethods?: readonly string[];
}>(base: T): T;

export declare function withRuntimeBasePath(pathname: string): string;

export declare function workboardCardsToProjectBoardWorkspace(cards: readonly OpenClawWorkboardCard[]): ProjectBoardWorkspaceSnapshot;

export declare function workboardCardToProjectBoardBacklogItem(card: OpenClawWorkboardCard): ProjectBoardBacklogItem;

export declare function workboardPriorityToProjectBoard(priority: OpenClawWorkboardPriority): ProjectBoardBacklogPriority;

export declare function workboardStatusToProjectBoard(status: OpenClawWorkboardStatus): ProjectBoardBacklogStatus;