@lucern/sdk 0.2.0-alpha.7 → 0.2.0-alpha.9

package/dist/client.d.ts

@@ -0,0 +1,2378 @@
+import { AudiencesClientConfig, AudienceRegistryInput, AudienceGrantInput, AudienceGrantRevokeInput } from './audiencesClient.js';
+import { SchemaClientConfig, SchemaPackInstallInput, SchemaEntitlementInput } from './schemaClient.js';
+import { HarnessClientConfig, HarnessAgentWriteInput, HarnessInvokeManagedAgentInput, HarnessToolWriteInput, HarnessExecuteToolInput, HarnessExecuteToolResult, HarnessStartRunInput, HarnessRunReportInput, HarnessCompleteRunInput } from './harnessClient.js';
+import { IdentityClientConfig, ClerkUserSearchResult } from './identityClient.js';
+import { AdminClientConfig, TenantApiKeyRecord, TenantVaultSecretRecord, TenantConfigRecord, TenantModelRoutingSnapshot } from './adminClient.js';
+import { ControlObjectOwnershipContract } from './controlObjectOwnership.js';
+import { BeliefsClientConfig, CreateBeliefInput, ModulateConfidenceInput, ForkBeliefInput, UpdateBeliefStatusInput, UpdateBeliefRationaleInput, LinkBeliefsInput, UnlinkBeliefEvidenceInput, UpdateBeliefCriticalityInput, BatchUpdateBeliefCriticalityInput, ReassignBeliefsTopicInput } from './beliefsClient.js';
+import { PacksClientConfig, PackInstallInput, PackEnableInput, PackDisableInput, PackEntitlementInput, PackUninstallInput, PackUpgradeInput } from './packsClient.js';
+import { CustomToolRegistration, RegisteredCustomTool } from './customTools.js';
+import { PolicyClientConfig, PermissionDecision, PermissionKind, WritePolicyRecord, WritePolicyCreateInput, WritePolicyUpdateInput, TenantPolicyRecord, TenantPolicyPermission } from './policyClient.js';
+import { PlatformGatewaySuccess, GatewayScope } from './coreClient.js';
+import { OntologyClientConfig, OntologyBindingInput, OntologyDefinitionInput, OntologyDefinitionUpdateInput, OntologyVersionInput } from './ontologyClient.js';
+import { CompileContextInput, PublicCompiledContext } from './contextTypes.js';
+import { TopicsClientConfig, TopicListInput, TopicCreateInput, TopicUpdateInput, TopicTreeQuery, TopicCoverageQuery, TopicBulkCreateInput } from './topicsClient.js';
+import { AnswersClientConfig } from './answersClient.js';
+import { AuditClientConfig } from './auditClient.js';
+import { ContextClientConfig } from './contextClient.js';
+import { LensPromptTemplateReference, LensWorkflowTemplate, LensTaskTemplate } from './contracts/lens-workflow.contract.js';
+import { DecisionsClientConfig, RecordJudgmentInput, ListJudgmentsInput, RecordJudgmentOutcomeInput, GetJudgmentCalibrationInput, ListPendingJudgmentOutcomeReviewInput, GetJudgmentTransitionAuditIntegrityInput } from './decisionsClient.js';
+import { GraphClientConfig, ListNodesInput, GetNodeInput, CreateNodeInput, UpdateNodeInput, BatchCreateNodesInput, SupersedeNodeInput, VerifyNodeInput, HardDeleteNodeInput, CreateEdgeInput, NeighborhoodInput, QueryNodesInput, ListEdgesInput, QueryEdgesInput, DeleteEdgeInput, TraverseInput, AnalyzeInput, BiasInput, GapsInput, SearchInput, PathInput, AnalyticsInput } from './graphClient.js';
+import { LearningClientConfig } from './learningClient.js';
+import { McpParityClientConfig } from './mcpParityClient.js';
+import { ReportsClientConfig } from './reportsClient.js';
+import { JsonObject, ListResult, PlatformGraphNode, PlatformGraphEdge, GraphNeighborhoodResponse, JsonArray, RecordJudgmentResponse, ListJudgmentsResponse, GetJudgmentResponse, RecordJudgmentOutcomeResponse, JudgmentReadinessResponse, JudgmentCalibrationResponse, PendingJudgmentOutcomeRecord, JudgmentTransitionAuditIntegrityResponse, TopicIdentifierInput, WorkflowBranchRecord, WorkflowLensRecord, WorkflowLensBindingRecord, WorkflowWorktreeRecord, ListWorktreesResponse, PushWorktreeResponse, OpenPullRequestResponse, TopicListResponse, TopicRecord, TopicTreeResponse, TopicCoverageResponse, PlatformBeliefRecord, ModulateConfidenceResponse, ForkBeliefResponse, DeleteEdgeResponse, GraphPathResponse, GraphAnalyticsResponse, MergeWorktreeResponse, ListTopicsResponse, SwitchTopicContextResponse, CreateTaskResponse, CompleteTaskResponse, UpdateTaskResponse, ReportTemplatesResponse, ReportWithSectionsResponse } from './types.js';
+import { WorkflowClientConfig, WorkflowLensPerspectiveType, WorkflowLensStatus, AddWorktreeInput, WorkflowWorktreeStatus, UpdateWorktreeTargetsInput, MergeInput, CreateTaskInput, CompleteTaskInput, UpdateTaskInput, WorkflowBranchStatus, CompleteWorktreeInput, AdvanceWorktreePhaseInput, SetWorktreePhaseInput, PatchWorktreeStateInput, BulkCreateWorktreesInput, ListTopicsInput, SwitchTopicContextInput } from './workflowClient.js';
+import 'zod';
+import './mcpTools-DPZxowDX.js';
+import './contracts/lens-filter.contract.js';
+import './contracts/workflow-runtime.contract.js';
+
+type ClientConfig = BeliefsClientConfig | GraphClientConfig | DecisionsClientConfig | AnswersClientConfig | ContextClientConfig | WorkflowClientConfig | AuditClientConfig | AdminClientConfig | IdentityClientConfig | PolicyClientConfig | PacksClientConfig | ReportsClientConfig | LearningClientConfig | McpParityClientConfig | OntologyClientConfig | HarnessClientConfig | SchemaClientConfig | AudiencesClientConfig | TopicsClientConfig;
+type CustomToolInput = JsonObject;
+type CustomToolInvoker = (input?: CustomToolInput) => Promise<unknown>;
+type CustomToolNamespace = Record<string, CustomToolInvoker>;
+type GatewayDataEnvelope<T extends Record<string, unknown>> = PlatformGatewaySuccess<T> & T;
+type BeliefsCompatCreateInput = {
+    topicId?: string;
+    text?: string;
+    canonicalText?: string;
+    formulation?: string;
+    rationale?: string;
+    worktreeId?: string;
+    pillar?: string;
+    sourceBeliefIds?: string[];
+    sourceType?: string;
+    beliefType?: string;
+    reversibility?: string;
+    predictionMeta?: JsonObject;
+    metadata?: JsonObject;
+};
+type BeliefsCompatForkInput = {
+    text?: string;
+    newFormulation?: string;
+    formulation?: string;
+    forkReason?: "refinement" | "contradiction_response" | "scope_change" | "confidence_collapse" | "manual";
+    rationale?: string;
+};
+type BeliefsCompatUpdateConfidenceInput = {
+    confidence: number;
+    trigger?: "evidence_added" | "evidence_removed" | "contradiction_detected" | "contradiction_resolved" | "manual" | "decay" | "agent_assessment" | "merge_outcome" | "worktree_outcome" | "worktree_completed";
+    rationale: string;
+    certainty?: number;
+    maxInlinePropagationTargets?: number;
+};
+/**
+ * Configuration for the high-level Lucern SDK client.
+ *
+ * At minimum, provide `apiKey` and `baseUrl`. The SDK handles
+ * authentication, retries, and idempotency automatically.
+ */
+type LucernClientConfig = ClientConfig & {
+    /** API key for authenticating with the Lucern platform. */
+    apiKey?: string;
+    /**
+     * Optional Clerk JWT for per-user identity and RBAC.
+     * When present, the SDK operates in user-scoped mode with
+     * pack-aware tool filtering. When absent, operates in agent mode.
+     */
+    userToken?: string;
+    /**
+     * Optional pack key for auto-install convenience.
+     * When set, the SDK will call `packs.install()` on first use
+     * to ensure the pack is available in the workspace.
+     */
+    packKey?: string;
+    /** Target environment. Defaults to production if not specified. */
+    environment?: "sandbox" | "production";
+};
+/**
+ * Create the high-level Lucern SDK client with all domain namespaces.
+ *
+ * @param config - Client configuration with API key, base URL, and optional settings.
+ * @returns The Lucern client with namespaced methods for beliefs, topics, evidence, decisions, and more.
+ */
+declare function createLucernClient(config?: LucernClientConfig): {
+    config: LucernClientConfig;
+    version: string;
+    search(query: string, options?: {
+        topicId?: string;
+        types?: string[];
+        status?: string;
+        minConfidence?: number;
+        limit?: number;
+        cursor?: string;
+    }): Promise<GatewayDataEnvelope<{
+        [x: string]: unknown;
+    } & {
+        cursor?: string;
+        total?: number;
+    } & {
+        beliefs?: {
+            [x: string]: unknown;
+        }[];
+        results?: {
+            [x: string]: unknown;
+        }[];
+    }>>;
+    events: {
+        list(query?: Parameters<(query?: {
+            topicId?: string;
+            after?: string;
+            types?: string[];
+            startTime?: number;
+            endTime?: number;
+            limit?: number;
+        }) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            events?: {
+                [x: string]: unknown;
+            }[];
+        }>>>[0]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            events?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        replay(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+    };
+    beliefs: {
+        create(input: BeliefsCompatCreateInput): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>>;
+        get(nodeId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>>;
+        refine(nodeId: string, textOrInput: string | {
+            text: string;
+            rationale?: string;
+        }, rationale?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>>;
+        updateConfidence(nodeId: string, input: BeliefsCompatUpdateConfidenceInput): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        modulateConfidence(nodeId: string, input: BeliefsCompatUpdateConfidenceInput): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updateStatus(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            status: "active" | "superseded" | "archived";
+            reason?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updateRationale(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            rationale?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        linkBeliefs(input: Parameters<(input: {
+            fromNodeId: string;
+            toNodeId: string;
+            edgeType: string;
+            weight?: number;
+            context?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        unlinkEvidence(input: Parameters<(input: {
+            beliefNodeId?: string;
+            beliefId?: string;
+            insightId?: string;
+            evidenceId?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updateCriticality(input: Parameters<(input: {
+            id?: string;
+            nodeId?: string;
+            beliefId?: string;
+            criticality: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        batchUpdateCriticality(input: Parameters<(input: {
+            updates: {
+                [x: string]: unknown;
+            }[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        reassignTopic(input: Parameters<(input: {
+            beliefNodeIds?: string[];
+            beliefIds?: string[];
+            targetTopicId: string;
+            reason?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        fork(nodeId: string, input: BeliefsCompatForkInput): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        }>>;
+        archive(nodeId: string, input?: string | {
+            reason?: string;
+            rationale?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(args: {
+            topicId?: string;
+            worktreeId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            beliefs?: ({
+                [x: string]: unknown;
+            } & {
+                id?: string;
+                beliefId?: string;
+                nodeId?: string;
+            })[];
+        }>>;
+        search: (args: {
+            query: string;
+            topicId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+        }) => Promise<{
+            results: Record<string, unknown>[];
+        }>;
+        lineage(nodeId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            beliefId?: string;
+            lineage?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        confidenceHistory(nodeId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        createContract(nodeId: string, input: Parameters<(id: string, input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        bisect(nodeId: string, input: Parameters<(id: string, input: {
+            expectedDirection: "overconfident" | "underconfident";
+            timeRange?: {
+                start: number;
+                end: number;
+            };
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+    };
+    webhooks: {
+        create(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(query?: Parameters<(query?: {
+            topicId?: string;
+        }) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            webhooks?: {
+                [x: string]: unknown;
+            }[];
+        }>>>[0]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            webhooks?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        get(id: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        update(id: string, input: Parameters<(id: string, input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        delete(id: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        test(id: string, input?: Parameters<(id: string, input?: {
+            topicId?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        deliveries(id: string, query?: Parameters<(id: string, query?: {
+            limit?: number;
+        }) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        health(id: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+    };
+    edges: {
+        create(args: {
+            sourceId: string;
+            targetId: string;
+            edgeType: string;
+            topicId?: string;
+            confidence?: number;
+            weight?: number;
+            context?: string;
+            reasoning?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        update(input: Parameters<(input: {
+            edgeId: string;
+            weight?: number;
+            confidence?: number;
+            context?: string;
+            derivationType?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        remove(input: Parameters<(input: {
+            edgeId: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        removeBetween(input: Parameters<(input: {
+            fromNodeId: string;
+            toNodeId: string;
+            edgeType?: string;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        batchCreate(input: Parameters<(input: {
+            edges: {
+                [x: string]: unknown;
+            }[];
+            skipLayerValidation?: boolean;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        delete(input: Parameters<(input: {
+            edgeIds: string[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(args: {
+            sourceId: string;
+            edgeType?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        }>>;
+        traverse(args: {
+            startNode: string;
+            direction?: string;
+            maxDepth?: number;
+            topicId?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+    };
+    evidence: {
+        create(args: {
+            text?: string;
+            canonicalText?: string;
+            topicId?: string;
+            source?: string;
+            sourceUrl?: string;
+            targetId?: string;
+            weight?: number;
+            metadata?: JsonObject;
+            title?: string;
+            content?: string;
+            contentType?: string;
+            kind?: string;
+            supports?: {
+                nodeId: string;
+                weight: number;
+                reasoning?: string;
+            };
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+        }>>;
+        add: (args: {
+            text?: string;
+            canonicalText?: string;
+            topicId?: string;
+            source?: string;
+            sourceUrl?: string;
+            targetId?: string;
+            weight?: number;
+            metadata?: JsonObject;
+            title?: string;
+            content?: string;
+            contentType?: string;
+            kind?: string;
+            supports?: {
+                nodeId: string;
+                weight: number;
+                reasoning?: string;
+            };
+        }) => Promise<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+        }>;
+        get(evidenceId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(args: {
+            topicId?: string;
+            targetId?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        }>>;
+        search(args: {
+            q?: string;
+            query?: string;
+            topicId?: string;
+            targetId?: string;
+            methodology?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        }>>;
+        link(args: {
+            evidenceId: string;
+            targetId?: string;
+            beliefId?: string;
+            questionId?: string;
+            targetType?: "belief" | "question" | string;
+            weight?: number;
+            rationale?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            edgeId?: string;
+        }>>;
+        linkToBelief(args: {
+            evidenceId: string;
+            beliefId: string;
+            weight: number;
+            rationale?: string;
+        }): Promise<{
+            beliefId: string;
+            edgeId?: string;
+        }>;
+        updateStatus(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        update(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        flagIncorrect(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        remove(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updateVerificationStatus(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+    };
+    questions: {
+        create(args: {
+            text: string;
+            topicId?: string;
+            priority?: string;
+            linkedBeliefId?: string;
+            metadata?: JsonObject;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        get(questionId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        refine(questionId: string, text: string, refinementReason?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(args: {
+            topicId?: string;
+            status?: string;
+            priority?: string;
+            worktreeId?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            questions?: Array<{
+                [x: string]: unknown;
+            } & {
+                priority?: string;
+            }>;
+        }>>;
+        updateStatus(questionId: string, status: string, rationale?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        batchCreate(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        add(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updatePriority(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        advanceToConviction(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        updateConviction(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        finalizeConviction(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        update(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        delete(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        answer(questionId: string, input: {
+            text: string;
+            confidence?: string;
+            evidenceIds?: string[];
+            rationale?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        archive(questionId: string, reason?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        linkEvidence(args: {
+            evidenceId: string;
+            questionId: string;
+            relevance?: number;
+            weight?: number;
+            rationale?: string;
+        }): Promise<{
+            questionId: string;
+            relevance: number | undefined;
+            edgeId?: string;
+        }>;
+        getHighPriority(args: {
+            topicId?: string;
+            limit?: number;
+            includeAnswered?: boolean;
+        }): Promise<{
+            questions: ({
+                priority?: string;
+            } & Record<string, unknown>)[];
+        }>;
+        findMissing(args: {
+            topicId?: string;
+            minConfidence?: number;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    graph: {
+        nodes: {
+            list(query: Parameters<(query: ListNodesInput) => Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>>[0]): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+            get(input: string | Parameters<(query: GetNodeInput) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            create(input: Parameters<(input: CreateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            update(input: Parameters<(input: UpdateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            batchCreate(input: Parameters<(input: BatchCreateNodesInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            supersede(input: Parameters<(input: SupersedeNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            verify(input: Parameters<(input: VerifyNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            hardDelete(input: Parameters<(input: HardDeleteNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+        createEdge(input: Parameters<(input: CreateEdgeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphEdge>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphEdge>>;
+        neighborhood(args: Parameters<(query: NeighborhoodInput) => Promise<PlatformGatewaySuccess<GraphNeighborhoodResponse>>>[0]): Promise<GatewayDataEnvelope<GraphNeighborhoodResponse>>;
+        queryLineage: (nodeId: string, depth?: number) => Promise<{
+            chain: {
+                nodeId: {};
+                relation: string;
+            }[];
+            forkTree: {
+                nodeId: string;
+                parentCount: number;
+                childCount: number;
+                children: never[];
+            };
+            depth: number;
+            beliefId: string | undefined;
+            lineage: {
+                [x: string]: unknown;
+            }[];
+        }>;
+        getConfidenceHistory: (nodeId: string) => Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        getAuditTrail: (nodeId: string, limit?: number) => Promise<{
+            entries: {
+                action: string;
+                actor: string;
+                timestamp: number;
+                rationale: string;
+                before: string | number | boolean | JsonObject | JsonArray | null;
+                after: string | number | boolean | JsonObject | JsonArray | null;
+            }[];
+        }>;
+        traverse(args: {
+            startNode: string;
+            direction?: string;
+            maxDepth?: number;
+            topicId?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        analyze(args: {
+            topicId?: string;
+            limit?: number;
+            metric?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        bias(args: {
+            topicId?: string;
+            threshold?: number;
+            limit?: number;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        gaps(args: {
+            topicId?: string;
+            minConfidence?: number;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        falsify(args: {
+            topicId?: string;
+            beliefId?: string;
+            beliefIds?: string[];
+            minConfidence?: number;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        traceEntityImpact(args: {
+            nodeId: string;
+            topicId?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        searchBeliefs: (args: {
+            query: string;
+            topicId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+        }) => Promise<{
+            results: Record<string, unknown>[];
+        }>;
+        findContradictions: (args: {
+            topicId?: string;
+            nodeId?: string;
+            status?: string;
+        }) => Promise<{
+            contradictions: {
+                beliefA: string;
+                beliefB: string;
+                description: string;
+                severity: string;
+                status: string;
+                defeatType: string;
+            }[];
+        }>;
+        bisectConfidence: (nodeId: string, args: {
+            expectedDirection: "overconfident" | "underconfident";
+        }) => Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        listBeliefs: (args: {
+            topicId?: string;
+            worktreeId?: string;
+            status?: string;
+            minConfidence?: number;
+            limit?: number;
+            cursor?: string;
+        }) => Promise<({
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        })[]>;
+        detectConfirmationBias(topicId: string, threshold?: number): Promise<{
+            topicId: string;
+            threshold: number;
+            success: true;
+            data: Record<string, unknown>;
+            correlationId: string;
+            policyTraceId: string | null;
+            idempotentReplay: boolean;
+        }>;
+        getStructureAnalysis(topicId: string): Promise<{
+            topicId: string;
+            success: true;
+            data: Record<string, unknown>;
+            correlationId: string;
+            policyTraceId: string | null;
+            idempotentReplay: boolean;
+        }>;
+        getFalsificationQuestions(topicId: string, beliefIds?: string[]): Promise<{
+            topicId: string;
+            questions: unknown;
+        }>;
+    };
+    judgments: {
+        create(input: RecordJudgmentInput): Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+        record(input: RecordJudgmentInput): Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+        list(query: Parameters<(query: ListJudgmentsInput) => Promise<PlatformGatewaySuccess<ListJudgmentsResponse>>>[0]): Promise<PlatformGatewaySuccess<ListJudgmentsResponse>>;
+        get(judgmentId: string): Promise<PlatformGatewaySuccess<GetJudgmentResponse>>;
+        recordOutcome(judgmentId: string, input: Parameters<(judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>>[1]): Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+        updateOutcome(judgmentId: string, input: Parameters<(judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>>[1]): Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+        readiness(topicId: string): Promise<PlatformGatewaySuccess<JudgmentReadinessResponse>>;
+        calibration(topicId: string): Promise<PlatformGatewaySuccess<JudgmentCalibrationResponse>>;
+        pendingOutcomeReview(topicId: string): Promise<PlatformGatewaySuccess<ListResult<PendingJudgmentOutcomeRecord, "reviews">>>;
+        transitionAuditIntegrity(args: {
+            topicId?: string;
+            judgmentId?: string;
+            includePassing?: boolean;
+        }): Promise<PlatformGatewaySuccess<JudgmentTransitionAuditIntegrityResponse>>;
+    };
+    worktrees: {
+        createBranch(input: Parameters<(input: {
+            name: string;
+            topicId?: string;
+            description?: string;
+            metadata?: JsonObject;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowBranchRecord>>>[0]): Promise<PlatformGatewaySuccess<WorkflowBranchRecord>>;
+        createLens(input: Parameters<(input: {
+            name: string;
+            workspaceId?: string;
+            topicId?: string;
+            description?: string;
+            perspectiveType: WorkflowLensPerspectiveType;
+            promptTemplates?: LensPromptTemplateReference[];
+            workflowTemplates?: LensWorkflowTemplate[];
+            taskTemplates?: LensTaskTemplate[];
+            filterCriteria?: JsonObject;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowLensRecord>>>[0]): Promise<PlatformGatewaySuccess<WorkflowLensRecord>>;
+        listLenses(query: Parameters<(query: {
+            workspaceId?: string;
+            topicId?: string;
+            status?: WorkflowLensStatus;
+            perspectiveType?: WorkflowLensPerspectiveType;
+        } & TopicIdentifierInput) => Promise<PlatformGatewaySuccess<ListResult<WorkflowLensRecord, "lenses">>>>[0]): Promise<PlatformGatewaySuccess<ListResult<WorkflowLensRecord, "lenses">>>;
+        applyLensToTopic(input: Parameters<(input: {
+            lensId: string;
+            topicId?: string;
+            metadata?: JsonObject;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>>[0]): Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>;
+        removeLensFromTopic(input: Parameters<(input: {
+            lensId: string;
+            topicId?: string;
+        } & TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>>[0]): Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>;
+        create(input: AddWorktreeInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        add(input: AddWorktreeInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        list(query: Parameters<(query: {
+            topicId?: string;
+            branchId?: string;
+            status?: WorkflowWorktreeStatus;
+            track?: string;
+            executionBand?: number;
+            limit?: number;
+        } & TopicIdentifierInput) => Promise<PlatformGatewaySuccess<ListResult<WorkflowWorktreeRecord, "worktrees">>>>[0]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            worktrees?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        activate(worktreeId: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        updateMetadata(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        update(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        updateTargets(input: Parameters<(input: UpdateWorktreeTargetsInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>>[0]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        listAll(query?: Parameters<(query?: {
+            status?: WorkflowWorktreeStatus;
+            track?: string;
+            executionBand?: number;
+            limit?: number;
+        }) => Promise<PlatformGatewaySuccess<ListWorktreesResponse>>>[0]): Promise<PlatformGatewaySuccess<ListWorktreesResponse>>;
+        merge(worktreeId: string, input: MergeInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        push(worktreeId: string, input: Parameters<(worktreeId: string, input: {
+            targetContext: string;
+            beliefIds?: string[];
+            metadata?: JsonObject;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PushWorktreeResponse>>>[1]): Promise<PlatformGatewaySuccess<PushWorktreeResponse>>;
+        openPullRequest(worktreeId: string, input: Parameters<(worktreeId: string, input: {
+            summary: string;
+            reviewers?: string[];
+            status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<OpenPullRequestResponse>>>[1]): Promise<PlatformGatewaySuccess<OpenPullRequestResponse>>;
+        pipelineSnapshot(topicId: string): Promise<PlatformGatewaySuccess<unknown>>;
+        complete(input: Parameters<(input: {
+            worktreeId: string;
+            keyFindings?: string[];
+            decisionsReached?: string[];
+            nextSteps?: string[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        advancePhase(worktreeId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        setPhase(worktreeId: string, phase: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        patchState(input: Parameters<(input: {
+            worktreeId: string;
+            patch: {
+                [x: string]: unknown;
+            };
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        bulkCreate(input: Parameters<(input: {
+            worktrees: unknown[];
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+    };
+    context: {
+        listTopics(query?: Parameters<(query?: TopicListInput) => Promise<PlatformGatewaySuccess<TopicListResponse>>>[0]): Promise<PlatformGatewaySuccess<TopicListResponse>>;
+        compile(topicId: string, input?: Parameters<(topicId: string, input?: CompileContextInput) => Promise<PlatformGatewaySuccess<PublicCompiledContext>>>[1]): Promise<PlatformGatewaySuccess<PublicCompiledContext>>;
+        recordScopeLearning(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        discover(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        analyzeTopicDensity(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        applyAutoBranching(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        seedBeliefLattice(input?: Parameters<(args?: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        getLatticeCoverage(input?: Parameters<(args?: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        matchEntityType(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        discoverEntityConnections(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        triggerBeliefReview(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    tasks: {
+        create(input: CreateTaskInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        complete(taskId: string, input: CompleteTaskInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        update(taskId: string, input: UpdateTaskInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        list(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            tasks?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+    };
+    topics: {
+        list(input?: Parameters<(query?: TopicListInput) => Promise<PlatformGatewaySuccess<TopicListResponse>>>[0]): Promise<PlatformGatewaySuccess<TopicListResponse>>;
+        get(topicId: string): Promise<PlatformGatewaySuccess<TopicRecord>>;
+        create(input: Parameters<(input: TopicCreateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<TopicRecord>>>[0]): Promise<PlatformGatewaySuccess<TopicRecord>>;
+        update(topicId: string, input: Parameters<(topicId: string, input: TopicUpdateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<TopicRecord>>>[1]): Promise<PlatformGatewaySuccess<TopicRecord>>;
+        tree(topicId: string, query?: Parameters<(topicId: string, query?: TopicTreeQuery) => Promise<PlatformGatewaySuccess<TopicTreeResponse>>>[1]): Promise<PlatformGatewaySuccess<TopicTreeResponse>>;
+        getTree(input: {
+            rootId: string;
+            maxDepth?: number;
+        }): Promise<PlatformGatewaySuccess<TopicTreeResponse>>;
+        coverage(topicId: string, query?: Parameters<(topicId: string, query?: TopicCoverageQuery) => Promise<PlatformGatewaySuccess<TopicCoverageResponse>>>[1]): Promise<PlatformGatewaySuccess<TopicCoverageResponse>>;
+        remove(topicId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        bulkCreate(input: Parameters<(input: TopicBulkCreateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    };
+    answers: {
+        create(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        get(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    };
+    contradictions: {
+        flag(args: {
+            beliefA: string;
+            beliefB: string;
+            description: string;
+            topicId?: string;
+            severity?: string;
+            defeatType?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        list(args: {
+            topicId?: string;
+            status?: string;
+            limit?: number;
+            cursor?: string;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        } & {
+            contradictions?: {
+                [x: string]: unknown;
+            }[];
+        }>>;
+        get(contradictionId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        find: (args: {
+            topicId?: string;
+            nodeId?: string;
+            status?: string;
+        }) => Promise<{
+            contradictions: {
+                beliefA: string;
+                beliefB: string;
+                description: string;
+                severity: string;
+                status: string;
+                defeatType: string;
+            }[];
+        }>;
+    };
+    ontologies: {
+        list(input?: {
+            tenantId?: string;
+            tier?: string;
+            status?: string;
+        }): Promise<GatewayDataEnvelope<{
+            ontologies: any[];
+            total: number;
+            items: any[];
+            definitions: any[];
+        }>>;
+        get(ontologyId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        bind(input: Parameters<(input: OntologyBindingInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: Parameters<(input: OntologyBindingInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        match(input: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: Parameters<(input: {
+            [x: string]: unknown;
+        }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[1]): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        create(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        update(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        archive(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        createVersion(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+        publishVersion(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        deprecateVersion(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        resolveEffective(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        raw: {
+            list(filters?: GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<{
+                ontologies: any[];
+                total: number;
+                items: any[];
+                definitions: any[];
+            }>>;
+            get(id: string): Promise<PlatformGatewaySuccess<unknown>>;
+            bind(input: OntologyBindingInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listDefinitions(filters?: GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<{
+                ontologies: any[];
+                total: number;
+                items: any[];
+                definitions: any[];
+            }>>;
+            getDefinition(id: string): Promise<PlatformGatewaySuccess<unknown>>;
+            createDefinition(input: OntologyDefinitionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateDefinition(id: string, input: OntologyDefinitionUpdateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            archiveDefinition(id: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listVersions(ontologyId: string, filters?: GatewayScope & {
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "versions">>>;
+            createVersion(ontologyId: string, input: OntologyVersionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            publishVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deprecateVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTopics(ontologyId: string): Promise<PlatformGatewaySuccess<ListResult<any, "topics">>>;
+            listTopicsByOntology(ontologyId: string): Promise<PlatformGatewaySuccess<ListResult<any, "topics">>>;
+        };
+    };
+    coordination: {
+        registerSession(input?: Parameters<(args?: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        heartbeatSession(input?: Parameters<(args?: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        endSession(input?: Parameters<(args?: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        listActiveSessions(input?: Parameters<(args?: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        sendAgentMessage(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        broadcastMessage(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        getInbox(input?: Parameters<(args?: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        claimFiles(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    policy: {
+        checkPermission(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<PermissionDecision>>;
+        listAccessibleTopics(input?: Parameters<(query?: GatewayScope & {
+            permission?: PermissionKind;
+            includeShared?: boolean;
+            principal?: string;
+            principalId?: string;
+            limit?: number;
+        }) => Promise<{
+            data: {
+                permission: PermissionKind;
+                topics: {
+                    [key: string]: unknown;
+                    topicId?: string;
+                    name?: string;
+                    type?: string;
+                    isOwner?: boolean;
+                }[];
+                total: number;
+                deniedTopics: {
+                    topicId: string;
+                    reasonCode: string;
+                }[];
+            };
+            success: true;
+            correlationId: string;
+            policyTraceId: string | null;
+            idempotentReplay: boolean;
+        }>>[0]): Promise<{
+            data: {
+                permission: PermissionKind;
+                topics: {
+                    [key: string]: unknown;
+                    topicId?: string;
+                    name?: string;
+                    type?: string;
+                    isOwner?: boolean;
+                }[];
+                total: number;
+                deniedTopics: {
+                    topicId: string;
+                    reasonCode: string;
+                }[];
+            };
+            success: true;
+            correlationId: string;
+            policyTraceId: string | null;
+            idempotentReplay: boolean;
+        }>;
+        filterByPermission(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<{
+            success: boolean;
+            data: {
+                permission: PermissionKind;
+                allowedTopicIds: string[];
+                deniedTopics: {
+                    topicId: string;
+                    reasonCode: string;
+                }[];
+                count: number;
+            };
+        }>;
+        manageWritePolicy(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        raw: {
+            listDecisions(query?: GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "decisions">>>;
+            grant(input: GatewayScope & {
+                topicId: string;
+                permission: PermissionKind;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+                expiresAt?: number;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revoke(input: GatewayScope & {
+                topicId: string;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listWritePolicies(query?: GatewayScope & {
+                topicId?: string;
+                role?: string;
+                toolCategory?: string;
+                enabled?: boolean;
+            }): Promise<{
+                data: {
+                    policies: WritePolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createWritePolicy(input: WritePolicyCreateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    created: boolean;
+                    policy: WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateWritePolicy(id: string, input: WritePolicyUpdateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    updated: boolean;
+                    policy: WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteWritePolicy(id: string, scope?: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                id?: string;
+                deleted?: boolean;
+            }>>;
+            listRolePolicies(query?: GatewayScope): Promise<{
+                data: {
+                    policies: TenantPolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createRolePolicy(input: GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateRolePolicy(id: string, input: GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteRolePolicy(id: string, scope?: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            checkPermission(query: GatewayScope & {
+                topicId?: string;
+                permission?: PermissionKind;
+                principal?: string;
+                principalId?: string;
+                beliefClusterId?: string;
+            }): Promise<PlatformGatewaySuccess<PermissionDecision>>;
+            listAccessibleTopics(query?: GatewayScope & {
+                permission?: PermissionKind;
+                includeShared?: boolean;
+                principal?: string;
+                principalId?: string;
+                limit?: number;
+            }): Promise<{
+                data: {
+                    permission: PermissionKind;
+                    topics: {
+                        [key: string]: unknown;
+                        topicId?: string;
+                        name?: string;
+                        type?: string;
+                        isOwner?: boolean;
+                    }[];
+                    total: number;
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            filterByPermission(input: GatewayScope & {
+                topicIds?: string[];
+                permission?: PermissionKind;
+                principal?: string;
+                principalId?: string;
+            }): Promise<{
+                success: boolean;
+                data: {
+                    permission: PermissionKind;
+                    allowedTopicIds: string[];
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                    count: number;
+                };
+            }>;
+        };
+    };
+    observations: {
+        ingest(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        getContext(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    coding: {
+        getCodeContext(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        getChangeHistory(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        recordAttempt(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        getFailureLog(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    contracts: {
+        create(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        list(input?: {
+            beliefNodeId?: string;
+            contractId?: string;
+            status?: string;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        evaluate(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+        getStatus(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
+    };
+    bootstrap: {
+        generateSessionHandoff(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    research: {
+        searchSources(args: {
+            query: string;
+            topicId?: string;
+            sources?: string[];
+        }): Promise<{
+            results: {
+                title: string;
+                url: string;
+                snippet: string;
+                relevanceScore: number;
+                suggestedEvidence: string;
+            }[];
+        }>;
+        executeDeepResearch(args: {
+            query: string;
+            topicId?: string;
+            depth?: "quick" | "standard" | "deep";
+        }): Promise<{
+            report: {
+                summary: string;
+                findings: {
+                    title: string;
+                    summary: string;
+                    sourceUrl: string;
+                }[];
+                sources: {
+                    title: string;
+                    url: string;
+                }[];
+                linkedEvidence: never[];
+                linkedQuestions: never[];
+            };
+        }>;
+    };
+    tools: {
+        register(registration: CustomToolRegistration): RegisteredCustomTool;
+        unregister(fullName: string): boolean;
+        list(): RegisteredCustomTool[];
+        clear(): void;
+        invoke(name: string, input?: CustomToolInput): Promise<unknown>;
+        namespace(namespace: string): CustomToolNamespace;
+    };
+    packs: {
+        /**
+         * Ensure the configured packKey is installed.
+         * No-op if no packKey was provided or if the pack is already installed.
+         * Called automatically on first API use when packKey is set.
+         */
+        ensurePack: () => Promise<void>;
+        /**
+         * Check if the configured pack has been installed in this session.
+         */
+        readonly isInstalled: boolean;
+        listCatalog(): Promise<PlatformGatewaySuccess<ListResult<any, "catalog">>>;
+        catalog(): Promise<PlatformGatewaySuccess<ListResult<any, "catalog">>>;
+        listStates(scope?: Parameters<(query?: GatewayScope) => Promise<PlatformGatewaySuccess<ListResult<any, "states">>>>[0]): Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+        states(scope?: Parameters<(query?: GatewayScope) => Promise<PlatformGatewaySuccess<ListResult<any, "states">>>>[0]): Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+        install(input: Parameters<(input: PackInstallInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        enable(input: Parameters<(input: PackEnableInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+        disable(input: Parameters<(input: PackDisableInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
+    };
+    nodes: {
+        list(query: Parameters<(query: ListNodesInput) => Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>>[0]): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+        get(input: string | Parameters<(query: GetNodeInput) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+        create(input: Parameters<(input: CreateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+        update(input: Parameters<(input: UpdateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+        batchCreate(input: Parameters<(input: BatchCreateNodesInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        supersede(input: Parameters<(input: SupersedeNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        verify(input: Parameters<(input: VerifyNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        hardDelete(input: Parameters<(input: HardDeleteNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    };
+    identity: {
+        whoami(): Promise<PlatformGatewaySuccess<{
+            principalId: string;
+            principalType: "user" | "human" | "service" | "group" | "external_viewer" | "agent";
+            tenantId: string | null;
+            workspaceId: string | null;
+            scopes: string[];
+            roles: string[];
+            isPlatformAdmin: boolean;
+            isTenantAdmin: boolean;
+            isWorkspaceAdmin: boolean;
+            authMode: string | undefined;
+            sessionId: string | undefined;
+            delegatedBy: string | undefined;
+            expiresAt: number | undefined;
+        }> & {
+            principalId: string;
+            principalType: "user" | "human" | "service" | "group" | "external_viewer" | "agent";
+            tenantId: string | null;
+            workspaceId: string | null;
+            scopes: string[];
+            roles: string[];
+            isPlatformAdmin: boolean;
+            isTenantAdmin: boolean;
+            isWorkspaceAdmin: boolean;
+            authMode: string | undefined;
+            sessionId: string | undefined;
+            delegatedBy: string | undefined;
+            expiresAt: number | undefined;
+        }>;
+    };
+    custom: CustomToolNamespace;
+    extensions: Record<string, CustomToolNamespace>;
+    raw: {
+        beliefs: {
+            createBelief(input: CreateBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformBeliefRecord>>;
+            modulateConfidence(beliefId: string, input: ModulateConfidenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ModulateConfidenceResponse>>;
+            forkBelief(beliefId: string, input: ForkBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ForkBeliefResponse>>;
+            updateBeliefStatus(input: UpdateBeliefStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            updateBeliefRationale(input: UpdateBeliefRationaleInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            linkBeliefs(input: LinkBeliefsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            unlinkBeliefEvidence(input: UnlinkBeliefEvidenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            updateBeliefCriticality(input: UpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            batchUpdateBeliefCriticality(input: BatchUpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            reassignBeliefsTopic(input: ReassignBeliefsTopicInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+        graph: {
+            listNodes(query: ListNodesInput): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+            queryNodes(query: QueryNodesInput): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphNode, "nodes">>>;
+            getNode(query: GetNodeInput): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            createNode(input: CreateNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            updateNode(input: UpdateNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            batchCreateNodes(input: BatchCreateNodesInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            supersedeNode(input: SupersedeNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            verifyNode(input: VerifyNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            hardDeleteNode(input: HardDeleteNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            listEdges(query: ListEdgesInput): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphEdge, "edges">>>;
+            queryEdges(query: QueryEdgesInput): Promise<PlatformGatewaySuccess<ListResult<PlatformGraphEdge, "edges">>>;
+            createEdge(input: CreateEdgeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphEdge>>;
+            deleteEdge(query: DeleteEdgeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<DeleteEdgeResponse>>;
+            neighborhood(query: NeighborhoodInput): Promise<PlatformGatewaySuccess<GraphNeighborhoodResponse>>;
+            traverse(query: TraverseInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            analyze(query?: AnalyzeInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            bias(query?: BiasInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            gaps(query: GapsInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            search(query: SearchInput): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            getNeighborhood(query: NeighborhoodInput): Promise<PlatformGatewaySuccess<GraphNeighborhoodResponse>>;
+            getPath(query: PathInput): Promise<PlatformGatewaySuccess<GraphPathResponse>>;
+            getAnalytics(query?: AnalyticsInput): Promise<PlatformGatewaySuccess<GraphAnalyticsResponse>>;
+        };
+        decisions: {
+            listJudgments(query: ListJudgmentsInput): Promise<PlatformGatewaySuccess<ListJudgmentsResponse>>;
+            getJudgment(judgmentId: string): Promise<PlatformGatewaySuccess<GetJudgmentResponse>>;
+            getJudgmentReadiness(query: {
+                topicId?: string;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<JudgmentReadinessResponse>>;
+            getJudgmentCalibration(query: GetJudgmentCalibrationInput): Promise<PlatformGatewaySuccess<JudgmentCalibrationResponse>>;
+            listPendingOutcomeReviews(query: ListPendingJudgmentOutcomeReviewInput): Promise<PlatformGatewaySuccess<ListResult<PendingJudgmentOutcomeRecord, "reviews">>>;
+            listPendingJudgmentOutcomeReview(query: ListPendingJudgmentOutcomeReviewInput): Promise<PlatformGatewaySuccess<ListResult<PendingJudgmentOutcomeRecord, "reviews">>>;
+            getJudgmentTransitionAuditIntegrity(query: GetJudgmentTransitionAuditIntegrityInput): Promise<PlatformGatewaySuccess<JudgmentTransitionAuditIntegrityResponse>>;
+            createJudgment(input: RecordJudgmentInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+            recordJudgment(input: RecordJudgmentInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<RecordJudgmentResponse>>;
+            updateJudgmentOutcome(judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+            recordJudgmentOutcome(judgmentId: string, input: RecordJudgmentOutcomeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<RecordJudgmentOutcomeResponse>>;
+        };
+        workflow: {
+            listBranches(query: {
+                topicId?: string;
+                status?: WorkflowBranchStatus;
+                limit?: number;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<ListResult<WorkflowBranchRecord, "branches">>>;
+            createBranch(input: {
+                name: string;
+                topicId?: string;
+                description?: string;
+                metadata?: JsonObject;
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowBranchRecord>>;
+            listLenses(query: {
+                workspaceId?: string;
+                topicId?: string;
+                status?: WorkflowLensStatus;
+                perspectiveType?: WorkflowLensPerspectiveType;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<ListResult<WorkflowLensRecord, "lenses">>>;
+            createLens(input: {
+                name: string;
+                workspaceId?: string;
+                topicId?: string;
+                description?: string;
+                perspectiveType: WorkflowLensPerspectiveType;
+                promptTemplates?: LensPromptTemplateReference[];
+                workflowTemplates?: LensWorkflowTemplate[];
+                taskTemplates?: LensTaskTemplate[];
+                filterCriteria?: JsonObject;
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowLensRecord>>;
+            applyLensToTopic(input: {
+                lensId: string;
+                topicId?: string;
+                metadata?: JsonObject;
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>;
+            removeLensFromTopic(input: {
+                lensId: string;
+                topicId?: string;
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowLensBindingRecord>>;
+            listWorktrees(query: {
+                topicId?: string;
+                branchId?: string;
+                status?: WorkflowWorktreeStatus;
+                track?: string;
+                executionBand?: number;
+                limit?: number;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<ListResult<WorkflowWorktreeRecord, "worktrees">>>;
+            listAllWorktrees(query?: {
+                status?: WorkflowWorktreeStatus;
+                track?: string;
+                executionBand?: number;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListWorktreesResponse>>;
+            createWorktree(input: AddWorktreeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>;
+            addWorktree(input: AddWorktreeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>;
+            merge(worktreeId: string, input: MergeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<MergeWorktreeResponse>>;
+            activateWorktree(worktreeId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>;
+            updateWorktreeTargets(input: UpdateWorktreeTargetsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>;
+            completeWorktree(input: CompleteWorktreeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            advanceWorktreePhase(input: AdvanceWorktreePhaseInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            setWorktreePhase(input: SetWorktreePhaseInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            patchWorktreeState(input: PatchWorktreeStateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            bulkCreateWorktrees(input: BulkCreateWorktreesInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            openPullRequest(worktreeId: string, input: {
+                summary: string;
+                reviewers?: string[];
+                status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<OpenPullRequestResponse>>;
+            push(worktreeId: string, input: {
+                targetContext: string;
+                beliefIds?: string[];
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PushWorktreeResponse>>;
+            listTopics(query?: ListTopicsInput): Promise<PlatformGatewaySuccess<ListTopicsResponse>>;
+            switchTopicContext(input: SwitchTopicContextInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<SwitchTopicContextResponse>>;
+            createTask(input: CreateTaskInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<CreateTaskResponse>>;
+            completeTask(taskId: string, input: CompleteTaskInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<CompleteTaskResponse>>;
+            updateTask(taskId: string, input: UpdateTaskInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<UpdateTaskResponse>>;
+            createPillar(input: {
+                name: string;
+                topicId?: string;
+                description?: string;
+                metadata?: JsonObject;
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowBranchRecord>>;
+            createSprint(input: {
+                title: string;
+                topicId?: string;
+                branchId?: string;
+                hypothesis?: string;
+                beliefIds?: string[];
+            } & TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<WorkflowWorktreeRecord>>;
+            completeSprint(worktreeId: string, input: MergeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<MergeWorktreeResponse>>;
+            requestReview(worktreeId: string, input: {
+                summary: string;
+                reviewers?: string[];
+                status?: "pending_review" | "changes_requested" | "approved" | "blocked";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<OpenPullRequestResponse>>;
+            publishFindings(worktreeId: string, input: {
+                targetContext: string;
+                beliefIds?: string[];
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PushWorktreeResponse>>;
+        };
+        audit: {
+            listEvents(query?: GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
+                limit?: number;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<ListResult<any, "events">>>;
+        };
+        admin: {
+            listTenants(query?: {
+                status?: "active" | "disabled" | "archived";
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "tenants">>>;
+            createTenant(input: {
+                key: string;
+                slug?: string;
+                name: string;
+                status?: "active" | "disabled" | "archived";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getControlObjectOwnership(): Promise<PlatformGatewaySuccess<ControlObjectOwnershipContract>>;
+            getControlObjectOwnershipContract(): Promise<PlatformGatewaySuccess<ControlObjectOwnershipContract>>;
+            listWorkspaces(query?: GatewayScope & {
+                status?: "active" | "archived";
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "workspaces">>>;
+            createWorkspace(input: GatewayScope & {
+                workspaceId?: string;
+                key?: string;
+                slug?: string;
+                name?: string;
+                status?: "active" | "archived";
+                defaultProjectVisibility?: "private" | "team" | "firm" | "external" | "public";
+                restore?: boolean;
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listMemberships(query?: GatewayScope & {
+                principalId?: string;
+                status?: "active" | "revoked" | "expired";
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "memberships">>>;
+            createMembership(input: GatewayScope & {
+                membershipId?: string;
+                principalId: string;
+                role: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                status?: "active" | "revoked" | "expired";
+                source?: "bootstrap" | "manual" | "sync" | "invitation";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateMembership(input: GatewayScope & {
+                membershipId?: string;
+                principalId: string;
+                role: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                status?: "active" | "revoked" | "expired";
+                source?: "bootstrap" | "manual" | "sync" | "invitation";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertMembership(input: GatewayScope & {
+                membershipId?: string;
+                principalId: string;
+                role: "platform_admin" | "tenant_admin" | "workspace_admin" | "editor" | "viewer" | "auditor" | "service_agent";
+                status?: "active" | "revoked" | "expired";
+                source?: "bootstrap" | "manual" | "sync" | "invitation";
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTenantApiKeys(scope: GatewayScope & {
+                status?: "active" | "revoked" | "expired";
+            }): Promise<{
+                data: {
+                    keys: TenantApiKeyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createTenantApiKey(input: GatewayScope & {
+                label?: string;
+                scopes: string[];
+                expiresAt?: number;
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    key: TenantApiKeyRecord | null;
+                    plaintextKey: string | undefined;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            revokeTenantApiKey(keyId: string, input?: GatewayScope & {
+                reason?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTenantVaultSecrets(scope: GatewayScope): Promise<{
+                data: {
+                    secrets: TenantVaultSecretRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createTenantVaultSecret(input: GatewayScope & {
+                name: string;
+                description?: string;
+                value: string;
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    secret: TenantVaultSecretRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateTenantVaultSecret(secretId: string, input: GatewayScope & {
+                name: string;
+                description?: string;
+                value?: string;
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    secret: TenantVaultSecretRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteTenantVaultSecret(secretId: string, scope: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTenantSecrets(scope: GatewayScope & {
+                providerId?: string;
+                status?: "active" | "revoked";
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertTenantSecret(input: GatewayScope & {
+                providerId: string;
+                apiKey: string;
+                label?: string;
+                modelSlotIds?: string[];
+                passThroughOnly?: boolean;
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revokeTenantSecret(secretRef: string, input: GatewayScope & {
+                reason?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getTenantConfig(scope: GatewayScope & {
+                tenantId: string;
+            }): Promise<PlatformGatewaySuccess<TenantConfigRecord>>;
+            getTenantModelRouting(scope: GatewayScope & {
+                tenantId: string;
+            }): Promise<PlatformGatewaySuccess<TenantModelRoutingSnapshot>>;
+            upsertTenantConfig(input: GatewayScope & Omit<TenantConfigRecord, "updatedAt" | "updatedBy">, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TenantConfigRecord>>;
+            listGroups(scope?: GatewayScope & {
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            createGroup(input: GatewayScope & {
+                name: string;
+                groupKey?: string;
+                groupType?: string;
+                description?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateGroup(groupId: string, input: GatewayScope & {
+                name?: string;
+                description?: string;
+                workspaceId?: string;
+                clearWorkspaceId?: boolean;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deleteGroup(groupId: string, input?: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listGroupMembers(query: GatewayScope & {
+                groupId: string;
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            addGroupMember(input: GatewayScope & {
+                groupId: string;
+                principalId: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            removeGroupMember(input: GatewayScope & {
+                groupId: string;
+                principalId: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listPackGroupAssignments(query?: GatewayScope & {
+                groupId?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            assignPackToGroup(input: GatewayScope & {
+                groupId: string;
+                packKey: string;
+                packVersion?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            removePackFromGroup(input: GatewayScope & {
+                groupId: string;
+                packKey: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        identity: {
+            whoami(): Promise<PlatformGatewaySuccess<{
+                principalId: string;
+                principalType: "user" | "human" | "service" | "group" | "external_viewer" | "agent";
+                tenantId: string | null;
+                workspaceId: string | null;
+                scopes: string[];
+                roles: string[];
+                isPlatformAdmin: boolean;
+                isTenantAdmin: boolean;
+                isWorkspaceAdmin: boolean;
+                authMode: string | undefined;
+                sessionId: string | undefined;
+                delegatedBy: string | undefined;
+                expiresAt: number | undefined;
+            }>>;
+            listPrincipals(query?: GatewayScope & {
+                status?: string;
+                principalType?: string;
+                query?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "principals">>>;
+            createPrincipal(input: GatewayScope & {
+                principalId: string;
+                principalType: "user" | "group" | "service" | "external_viewer";
+                clerkId?: string;
+                email?: string;
+                displayName?: string;
+                status?: "active" | "disabled" | "revoked";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updatePrincipal(input: GatewayScope & {
+                principalId: string;
+                principalType: "user" | "group" | "service" | "external_viewer";
+                clerkId?: string;
+                email?: string;
+                displayName?: string;
+                status?: "active" | "disabled" | "revoked";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertPrincipal(input: GatewayScope & {
+                principalId: string;
+                principalType: "user" | "group" | "service" | "external_viewer";
+                clerkId?: string;
+                email?: string;
+                displayName?: string;
+                status?: "active" | "disabled" | "revoked";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listKeys(query?: GatewayScope & {
+                principalId?: string;
+                status?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "keys">>>;
+            createKey(input: GatewayScope & {
+                principalId: string;
+                keyId?: string;
+                token?: string;
+                scopes?: string[];
+                environment?: "sandbox" | "production";
+                expiresInDays?: number;
+                rateLimitTier?: "free" | "developer" | "partner";
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            rotateKey(keyId: string, input?: {
+                replacementKeyId?: string;
+                replacementToken?: string;
+                replacementExpiresInDays?: number;
+                gracePeriodHours?: number;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deleteKey(keyId: string, input?: {
+                reason?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revokeKey(keyId: string, input?: {
+                reason?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            searchClerkUsers(q: string): Promise<PlatformGatewaySuccess<ClerkUserSearchResult[]>>;
+        };
+        policy: {
+            listDecisions(query?: GatewayScope & {
+                action?: string;
+                decision?: string;
+                traceId?: string;
+                principalId?: string;
+                topicId?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "decisions">>>;
+            grant(input: GatewayScope & {
+                topicId: string;
+                permission: PermissionKind;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+                expiresAt?: number;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revoke(input: GatewayScope & {
+                topicId: string;
+                principal?: string;
+                principalId?: string;
+                groupId?: string;
+                beliefClusterId?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listWritePolicies(query?: GatewayScope & {
+                topicId?: string;
+                role?: string;
+                toolCategory?: string;
+                enabled?: boolean;
+            }): Promise<{
+                data: {
+                    policies: WritePolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createWritePolicy(input: WritePolicyCreateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    created: boolean;
+                    policy: WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateWritePolicy(id: string, input: WritePolicyUpdateInput, idempotencyKey?: string): Promise<{
+                data: {
+                    id: string | undefined;
+                    updated: boolean;
+                    policy: WritePolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteWritePolicy(id: string, scope?: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<{
+                id?: string;
+                deleted?: boolean;
+            }>>;
+            listRolePolicies(query?: GatewayScope): Promise<{
+                data: {
+                    policies: TenantPolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createRolePolicy(input: GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateRolePolicy(id: string, input: GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteRolePolicy(id: string, scope?: GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            checkPermission(query: GatewayScope & {
+                topicId?: string;
+                permission?: PermissionKind;
+                principal?: string;
+                principalId?: string;
+                beliefClusterId?: string;
+            }): Promise<PlatformGatewaySuccess<PermissionDecision>>;
+            listAccessibleTopics(query?: GatewayScope & {
+                permission?: PermissionKind;
+                includeShared?: boolean;
+                principal?: string;
+                principalId?: string;
+                limit?: number;
+            }): Promise<{
+                data: {
+                    permission: PermissionKind;
+                    topics: {
+                        [key: string]: unknown;
+                        topicId?: string;
+                        name?: string;
+                        type?: string;
+                        isOwner?: boolean;
+                    }[];
+                    total: number;
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            filterByPermission(input: GatewayScope & {
+                topicIds?: string[];
+                permission?: PermissionKind;
+                principal?: string;
+                principalId?: string;
+            }): Promise<{
+                success: boolean;
+                data: {
+                    permission: PermissionKind;
+                    allowedTopicIds: string[];
+                    deniedTopics: {
+                        topicId: string;
+                        reasonCode: string;
+                    }[];
+                    count: number;
+                };
+            }>;
+        };
+        answers: {
+            get(questionId: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+        ontology: {
+            list(filters?: GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<{
+                ontologies: any[];
+                total: number;
+                items: any[];
+                definitions: any[];
+            }>>;
+            get(id: string): Promise<PlatformGatewaySuccess<unknown>>;
+            bind(input: OntologyBindingInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listDefinitions(filters?: GatewayScope & {
+                tenantId?: string;
+                tier?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<{
+                ontologies: any[];
+                total: number;
+                items: any[];
+                definitions: any[];
+            }>>;
+            getDefinition(id: string): Promise<PlatformGatewaySuccess<unknown>>;
+            createDefinition(input: OntologyDefinitionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateDefinition(id: string, input: OntologyDefinitionUpdateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            archiveDefinition(id: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listVersions(ontologyId: string, filters?: GatewayScope & {
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "versions">>>;
+            createVersion(ontologyId: string, input: OntologyVersionInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            publishVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deprecateVersion(ontologyId: string, versionId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTopics(ontologyId: string): Promise<PlatformGatewaySuccess<ListResult<any, "topics">>>;
+            listTopicsByOntology(ontologyId: string): Promise<PlatformGatewaySuccess<ListResult<any, "topics">>>;
+        };
+        mcpParity: {
+            sessionId: `${string}-${string}-${string}-${string}-${string}`;
+            listTopics(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            createTopic(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getTopic(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            getTopicTree(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            activateWorktree(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateWorktreeMetadata(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateWorktreeTargets(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listAllWorktrees(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            pipelineSnapshot(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            recordScopeLearning(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            discover(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            analyzeTopicDensity(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            applyAutoBranching(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            seedBeliefLattice(args?: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getLatticeCoverage(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            matchEntityType(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            discoverEntityConnections(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            triggerBeliefReview(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listOntologies(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            getOntology(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            applyOntology(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            createOntology(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateOntology(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            archiveOntology(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            createOntologyVersion(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            publishOntologyVersion(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deprecateOntologyVersion(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            resolveEffectiveOntology(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            registerSession(args?: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            heartbeatSession(args?: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            endSession(args?: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listActiveSessions(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            sendAgentMessage(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            broadcastMessage(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getAgentInbox(args?: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            claimFiles(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTasks(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            createAnswer(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getAnswer(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            flagContradiction(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            ingestObservation(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getObservationContext(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            getCodeContext(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            getChangeHistory(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            recordAttempt(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getFailureLog(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            createEpistemicContract(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            evaluateContract(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getContractStatus(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            checkPermission(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            filterByPermission(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+            manageWritePolicy(args: JsonObject, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            generateSessionHandoff(args: JsonObject): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        packs: {
+            listCatalog(): Promise<PlatformGatewaySuccess<ListResult<any, "catalog">>>;
+            getCatalog(): Promise<PlatformGatewaySuccess<ListResult<any, "catalog">>>;
+            getDiscoveryCatalog(): Promise<PlatformGatewaySuccess<unknown>>;
+            getDiscoveryDetail(packKey: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listStates(query?: GatewayScope): Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+            getStates(query?: GatewayScope): Promise<PlatformGatewaySuccess<ListResult<any, "states">>>;
+            getHealth(packKey: string, query?: GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            listTelemetry(query?: GatewayScope & {
+                lookbackHours?: number;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "telemetry">>>;
+            getTelemetry(query?: GatewayScope & {
+                lookbackHours?: number;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "telemetry">>>;
+            createEntitlement(input: PackEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateEntitlement(input: PackEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertEntitlement(input: PackEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            install(input: PackInstallInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            enable(input: PackEnableInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            disable(input: PackDisableInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            uninstall(input: PackUninstallInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upgrade(input: PackUpgradeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        reports: {
+            listTemplates(args?: {
+                slug?: string;
+            }): Promise<PlatformGatewaySuccess<ReportTemplatesResponse>>;
+            getTemplates(args?: {
+                slug?: string;
+            }): Promise<PlatformGatewaySuccess<ReportTemplatesResponse>>;
+            listReports(input: TopicIdentifierInput, args?: {
+                summary?: boolean;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "reports">>>;
+            getReport(reportId: string): Promise<PlatformGatewaySuccess<ReportWithSectionsResponse>>;
+        };
+        learning: {
+            listRecentExecutions(args?: {
+                namespace?: string;
+                topicId?: string;
+                audienceMode?: string;
+                success?: boolean;
+                limit?: number;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<ListResult<any, "executions">>>;
+            getRecentExecutions(args?: {
+                namespace?: string;
+                topicId?: string;
+                audienceMode?: string;
+                success?: boolean;
+                limit?: number;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<ListResult<any, "executions">>>;
+            getExecutionStats(args?: {
+                namespace?: string;
+                topicId?: string;
+                audienceMode?: string;
+                hours?: number;
+            } & TopicIdentifierInput): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        harness: {
+            listAgentDefinitions(scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "agents">>>;
+            getAgentDefinition(agentId: string, scope?: GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            createAgentDefinition(input: HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            registerAgentDefinition(input: HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateAgentDefinition(agentId: string, input: HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            invokeManagedAgentDefinition(agentId: string, input: Omit<HarnessInvokeManagedAgentInput, "agentDefinitionId">, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listAgentRuns(agentId: string, scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "runs">>>;
+            listRunsForAgent(agentId: string, scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "runs">>>;
+            listToolDefinitions(scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+                gateClassification?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "tools">>>;
+            getToolDefinition(toolId: string, scope?: GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            createToolDefinition(input: HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            registerToolDefinition(input: HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateToolDefinition(toolId: string, input: HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            executeToolDefinition(toolId: string, input?: HarnessExecuteToolInput): Promise<PlatformGatewaySuccess<HarnessExecuteToolResult>>;
+            listRunEntries(scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "runs">>>;
+            listRunLedgerEntries(scope?: GatewayScope & {
+                status?: string;
+                limit?: number;
+                cursor?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "runs">>>;
+            startHarnessRun(input: HarnessStartRunInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getRunLedgerEntry(runId: string): Promise<PlatformGatewaySuccess<unknown>>;
+            reportHarnessRunEvent(runId: string, input: HarnessRunReportInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            heartbeatHarnessRun(runId: string, input: {
+                reportingToken: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            completeHarnessRun(runId: string, input: HarnessCompleteRunInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listPromptResolutions(query?: {
+                runId?: string;
+                promptName?: string;
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "prompts">>>;
+            getScopeTaxonomy(): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        schema: {
+            listPacks(scope?: GatewayScope): Promise<PlatformGatewaySuccess<ListResult<any, "packs">>>;
+            installPack(input: SchemaPackInstallInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getPack(packId: string, scope?: GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
+            listEntitlements(scope?: GatewayScope & {
+                packKey?: string;
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "entitlements">>>;
+            createEntitlement(input: SchemaEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateEntitlement(input: SchemaEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertEntitlement(input: SchemaEntitlementInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        audiences: {
+            listRegistry(query?: GatewayScope & {
+                effective?: boolean;
+                status?: "active" | "disabled" | "archived";
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "registryEntries">>>;
+            getRegistry(query?: GatewayScope & {
+                effective?: boolean;
+                status?: "active" | "disabled" | "archived";
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "registryEntries">>>;
+            createRegistryEntry(input: AudienceRegistryInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateRegistryEntry(input: AudienceRegistryInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertRegistry(input: AudienceRegistryInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listGrants(query?: GatewayScope & {
+                audienceKey?: string;
+                principalId?: string;
+                groupId?: string;
+                status?: "active" | "revoked" | "expired";
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "grants">>>;
+            getGrants(query?: GatewayScope & {
+                audienceKey?: string;
+                principalId?: string;
+                groupId?: string;
+                status?: "active" | "revoked" | "expired";
+            }): Promise<PlatformGatewaySuccess<ListResult<any, "grants">>>;
+            createGrant(input: AudienceGrantInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            grant(input: AudienceGrantInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deleteGrant(input: AudienceGrantRevokeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revokeGrant(input: AudienceGrantRevokeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+        };
+        topics: {
+            list(query?: TopicListInput): Promise<PlatformGatewaySuccess<TopicListResponse>>;
+            get(topicId: string): Promise<PlatformGatewaySuccess<TopicRecord>>;
+            create(input: TopicCreateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TopicRecord>>;
+            update(topicId: string, input: TopicUpdateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<TopicRecord>>;
+            getTree(topicId: string, query?: TopicTreeQuery): Promise<PlatformGatewaySuccess<TopicTreeResponse>>;
+            getCoverage(topicId: string, query?: TopicCoverageQuery): Promise<PlatformGatewaySuccess<TopicCoverageResponse>>;
+            remove(topicId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            bulkCreate(input: TopicBulkCreateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
+    };
+};
+
+export { type LucernClientConfig, createLucernClient };