@lucern/sdk 0.2.0-alpha.4 → 0.2.0-alpha.5

package/dist/{packages/sdk/src → lib/platform/sdk}/client.d.ts

@@ -49,12 +49,19 @@ type BeliefsCompatForkInput = {
 };
 type BeliefsCompatUpdateConfidenceInput = {
     confidence: number;
-    trigger?: "evidence_added" | "evidence_removed" | "contradiction_detected" | "contradiction_resolved" | "manual" | "decay" | "agent_assessment" | "merge_outcome" | "sprint_outcome" | "sprint_completed" | "worktree_outcome" | "worktree_completed";
+    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.
+ */
 export type LucernClientConfig = ClientConfig & {
+    /** API key for authenticating with the Lucern platform. */
     apiKey?: string;
     /**
      * Optional Clerk JWT for per-user identity and RBAC.
@@ -68,10 +75,14 @@ export type LucernClientConfig = ClientConfig & {
      * 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 facade.
+ * 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.
  */
 export declare function createLucernClient(config?: LucernClientConfig): {
     config: LucernClientConfig;
@@ -83,28 +94,169 @@ export declare function createLucernClient(config?: LucernClientConfig): {
         minConfidence?: number;
         limit?: number;
         cursor?: string;
-    }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-search/src/search").SearchResponse>>;
+    }): Promise<GatewayDataEnvelope<{
+        [x: string]: unknown;
+    } & {
+        cursor?: string;
+        total?: number;
+    } & {
+        beliefs?: {
+            [x: string]: unknown;
+        }[];
+        results?: {
+            [x: string]: unknown;
+        }[];
+    }>>;
     events: {
-        list(query?: Parameters<(query: Parameters<(query?: import("@/lucern/packages/events/src/types").EventListQuery) => Promise<import("@/lucern/packages/client-core/src/events").EventsListResponse>>[0]) => Promise<import("@/lucern/packages/client-core/src/events").EventsListResponse>>[0]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").EventListResult>>;
-        replay(input: Parameters<(input: Parameters<(input: import("@/lucern/packages/events/src/types").ReplayEventsInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/events").EventsReplayResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/events/src/types").ReplayEventsInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/events").EventsReplayResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/events").EventsReplayResponse>>[0]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").ReplayEventsResult>>;
+        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<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefRecord>>;
-        get(nodeId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefRecord>>;
+        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<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefRecord>>;
-        updateConfidence(nodeId: string, input: BeliefsCompatUpdateConfidenceInput): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefConfidenceUpdateResult>>;
-        modulateConfidence(nodeId: string, input: BeliefsCompatUpdateConfidenceInput): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefConfidenceUpdateResult>>;
-        fork(nodeId: string, input: BeliefsCompatForkInput): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefRecord & {
-            parentBeliefId: string;
-            forkReason: 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<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefArchiveResult>>;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
         list(args: {
             topicId?: string;
             worktreeId?: string;
@@ -112,7 +264,20 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             minConfidence?: number;
             limit?: number;
             cursor?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefListResult>>;
+        }): 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;
@@ -122,26 +287,95 @@ export declare function createLucernClient(config?: LucernClientConfig): {
         }) => Promise<{
             results: Record<string, unknown>[];
         }>;
-        lineage(nodeId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefLineageResult>>;
-        confidenceHistory(nodeId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefConfidenceHistoryResult>>;
-        createContract(nodeId: string, input: Parameters<(id: string, input: Parameters<(id: string, input: import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefContractCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>>[1], idempotencyKey?: Parameters<(id: string, input: import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefContractCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>>[2]) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsCreateContractResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefContractCreateResult>>;
-        bisect(nodeId: string, input: Parameters<(id: string, input: Parameters<(id: string, input: Omit<import("@/lucern/packages/domain-beliefs/src/beliefs").BisectBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>>[1], idempotencyKey?: Parameters<(id: string, input: Omit<import("@/lucern/packages/domain-beliefs/src/beliefs").BisectBeliefConfidenceInput, "id">, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>>[2]) => Promise<import("@/lucern/packages/client-core/src/beliefs").BeliefsBisectResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefBisectResult>>;
+        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: Parameters<(input: import("@/lucern/packages/events/src/types").WebhookCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksCreateResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/events/src/types").WebhookCreateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksCreateResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksCreateResponse>>[0]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookRecord>>;
-        list(query?: Parameters<(query?: Parameters<(query?: import("@/lucern/packages/client-core/src/webhooks").WebhookListQuery) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksListResponse>>[0]) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksListResponse>>[0]): Promise<GatewayDataEnvelope<{
-            webhooks: import("@/lucern/packages/events/src/types").WebhookRecord[];
-        }>>;
-        get(id: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookRecord>>;
-        update(id: string, input: Parameters<(id: string, input: Parameters<(id: string, input: import("@/lucern/packages/events/src/types").WebhookUpdateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksUpdateResponse>>[1], idempotencyKey?: Parameters<(id: string, input: import("@/lucern/packages/events/src/types").WebhookUpdateInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksUpdateResponse>>[2]) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksUpdateResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookRecord>>;
-        delete(id: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/client-core/src/webhooks").WebhookDeleteResult>>;
-        test(id: string, input?: Parameters<(id: string, input?: Parameters<(id: string, input?: {
+        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;
-        }, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksTestResponse>>[1], idempotencyKey?: Parameters<(id: string, input?: {
+        }) => 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<import("@/lucern/packages/client-core/src/webhooks").WebhooksTestResponse>>[2]) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksTestResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookTestResult>>;
-        deliveries(id: string, query?: Parameters<(id: string, query?: Parameters<(id: string, query?: import("@/lucern/packages/client-core/src/webhooks").WebhookDeliveriesQuery) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksDeliveriesResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/webhooks").WebhooksDeliveriesResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookDeliveriesResult>>;
-        health(id: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/events/src/types").WebhookHealthResult>>;
+        }, 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: {
@@ -153,19 +387,72 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             weight?: number;
             context?: string;
             reasoning?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/edges").EdgeRecord>>;
+        }): 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<import("@/lucern/packages/domain-edges/src/edges").EdgeListResult>>;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        }>>;
         traverse(args: {
             startNode: string;
             direction?: string;
             maxDepth?: number;
             topicId?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/edges").EdgeTraversalResult>>;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
     };
     evidence: {
         create(args: {
@@ -186,7 +473,11 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 weight: number;
                 reasoning?: string;
             };
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-evidence/src/evidence").EvidenceRecord>>;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
+        }>>;
         add: (args: {
             text?: string;
             canonicalText?: string;
@@ -205,35 +496,25 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 weight: number;
                 reasoning?: string;
             };
-        }) => Promise<import("@/lucern/packages/domain-evidence/src/evidence").EvidenceRecord | {
-            edgeId: string;
-            id: string;
-            nodeId: string;
-            evidenceId: string;
-            globalId?: string;
-            topicId?: string;
-            text: string;
-            title?: string;
-            kind?: string;
-            source?: string;
-            sourceType?: string;
-            externalSourceType?: string;
-            status?: string;
-            relation?: "supports" | "contradicts" | "neutral";
-            confidence?: number;
-            linkedBeliefId?: string;
-            linkedQuestionId?: string;
-            createdAt?: number;
-            updatedAt?: number;
-            metadata?: Record<string, unknown>;
+        }) => Promise<{
+            [x: string]: unknown;
+        } & {
+            id?: string;
         }>;
-        get(evidenceId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-evidence/src/evidence").EvidenceRecord>>;
+        get(evidenceId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
         list(args: {
             topicId?: string;
             targetId?: string;
             limit?: number;
             cursor?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-evidence/src/evidence").EvidenceListResult>>;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        }>>;
         search(args: {
             q?: string;
             query?: string;
@@ -242,7 +523,12 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             methodology?: string;
             limit?: number;
             cursor?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-evidence/src/evidence").EvidenceSearchPage>>;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            cursor?: string;
+            total?: number;
+        }>>;
         link(args: {
             evidenceId: string;
             targetId?: string;
@@ -251,7 +537,11 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             targetType?: "belief" | "question" | string;
             weight?: number;
             rationale?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-evidence/src/evidence").LinkEvidenceResult>>;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        } & {
+            edgeId?: string;
+        }>>;
         linkToBelief(args: {
             evidenceId: string;
             beliefId: string;
@@ -259,13 +549,43 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             rationale?: string;
         }): Promise<{
             beliefId: string;
-            edgeId: string;
-            evidenceId: string;
-            targetId: string;
-            targetType: import("@/lucern/packages/domain-evidence/src/evidence").EvidenceTargetType;
-            weight: number;
-            questionId?: 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: {
@@ -274,11 +594,14 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             priority?: string;
             linkedBeliefId?: string;
             metadata?: JsonObject;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionRecord>>;
-        get(questionId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionRecord>>;
-        refine(questionId: string, text: string, refinementReason?: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionRecord & {
-            previousText: string;
-            updatedText: string;
+        }): 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;
@@ -287,18 +610,88 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             worktreeId?: string;
             limit?: number;
             cursor?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionListResult>>;
-        updateStatus(questionId: string, status: string, rationale?: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionRecord & {
-            previousStatus: string;
-            newStatus: 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<import("@/lucern/packages/domain-questions/src/questions").QuestionAnswerResult>>;
-        archive(questionId: string, reason?: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-questions/src/questions").QuestionArchiveResult>>;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        archive(questionId: string, reason?: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
         linkEvidence(args: {
             evidenceId: string;
             questionId: string;
@@ -308,31 +701,38 @@ export declare function createLucernClient(config?: LucernClientConfig): {
         }): Promise<{
             questionId: string;
             relevance: number | undefined;
-            edgeId: string;
-            evidenceId: string;
-            targetId: string;
-            targetType: import("@/lucern/packages/domain-evidence/src/evidence").EvidenceTargetType;
-            weight: number;
-            beliefId?: string;
+            edgeId?: string;
         }>;
         getHighPriority(args: {
             topicId?: string;
             limit?: number;
             includeAnswered?: boolean;
         }): Promise<{
-            questions: import("@/lucern/packages/domain-questions/src/questions").QuestionRecord[];
+            questions: ({
+                priority?: string;
+            } & Record<string, unknown>)[];
         }>;
         findMissing(args: {
             topicId?: string;
             minConfidence?: number;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphGapsResult>>;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
     };
     graph: {
+        nodes: {
+            list(query: Parameters<(query: import("./graphClient").ListNodesInput) => Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphNode, "nodes">>>>[0]): Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphNode, "nodes">>>;
+            get(input: string | Parameters<(query: import("./graphClient").GetNodeInput) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            create(input: Parameters<(input: import("./graphClient").CreateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            update(input: Parameters<(input: import("./graphClient").UpdateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            batchCreate(input: Parameters<(input: import("./graphClient").BatchCreateNodesInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            supersede(input: Parameters<(input: import("./graphClient").SupersedeNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            verify(input: Parameters<(input: import("./graphClient").VerifyNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            hardDelete(input: Parameters<(input: import("./graphClient").HardDeleteNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        };
         createEdge(input: Parameters<(input: import("./graphClient").CreateEdgeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphEdge>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphEdge>>;
-        neighborhood(args: Parameters<(query: import("./graphClient").NeighborhoodInput) => Promise<PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>>[0]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphNeighborhoodResult>>;
+        neighborhood(args: Parameters<(query: import("./graphClient").NeighborhoodInput) => Promise<PlatformGatewaySuccess<import("./types").GraphNeighborhoodResponse>>>[0]): Promise<GatewayDataEnvelope<import("./types").GraphNeighborhoodResponse>>;
         queryLineage: (nodeId: string, depth?: number) => Promise<{
             chain: {
-                nodeId: string;
+                nodeId: {};
                 relation: string;
             }[];
             forkTree: {
@@ -342,10 +742,14 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 children: never[];
             };
             depth: number;
-            beliefId: string;
-            lineage: import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefLineageEntry[];
+            beliefId: string | undefined;
+            lineage: {
+                [x: string]: unknown;
+            }[];
         }>;
-        getConfidenceHistory: (nodeId: string) => Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefConfidenceHistoryResult>>;
+        getConfidenceHistory: (nodeId: string) => Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
         getAuditTrail: (nodeId: string, limit?: number) => Promise<{
             entries: {
                 action: string;
@@ -361,27 +765,29 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             direction?: string;
             maxDepth?: number;
             topicId?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphTraverseResult>>;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
         analyze(args: {
             topicId?: string;
             limit?: number;
             metric?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphAnalyzeResult>>;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
         bias(args: {
             topicId?: string;
             threshold?: number;
             limit?: number;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphBiasResult>>;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
         gaps(args: {
             topicId?: string;
             minConfidence?: number;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphGapsResult>>;
+        }): Promise<GatewayDataEnvelope<Record<string, unknown>>>;
         falsify(args: {
             topicId?: string;
             beliefId?: string;
             beliefIds?: string[];
             minConfidence?: number;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-graph/src/graph").GraphFalsifyResult>>;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
         traceEntityImpact(args: {
             nodeId: string;
             topicId?: string;
@@ -411,7 +817,9 @@ export declare function createLucernClient(config?: LucernClientConfig): {
         }>;
         bisectConfidence: (nodeId: string, args: {
             expectedDirection: "overconfident" | "underconfident";
-        }) => Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefBisectResult>>;
+        }) => Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
         listBeliefs: (args: {
             topicId?: string;
             worktreeId?: string;
@@ -419,32 +827,33 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             minConfidence?: number;
             limit?: number;
             cursor?: string;
-        }) => Promise<import("@/lucern/packages/domain-beliefs/src/beliefs").BeliefRecord[]>;
+        }) => Promise<({
+            [x: string]: unknown;
+        } & {
+            id?: string;
+            beliefId?: string;
+            nodeId?: string;
+        })[]>;
         detectConfirmationBias(topicId: string, threshold?: number): Promise<{
             topicId: string;
             threshold: number;
             success: true;
-            data: import("@/lucern/packages/domain-graph/src/graph").GraphBiasResult;
+            data: Record<string, unknown>;
             correlationId: string;
             policyTraceId: string | null;
             idempotentReplay: boolean;
-            metric: "confirmation_bias";
-            beliefs: import("@/lucern/packages/domain-graph/src/graph").GraphBiasBelief[];
-            payload: Record<string, unknown>;
         }>;
         getStructureAnalysis(topicId: string): Promise<{
             topicId: string;
             success: true;
-            data: import("@/lucern/packages/domain-graph/src/graph").GraphAnalyzeResult;
+            data: Record<string, unknown>;
             correlationId: string;
             policyTraceId: string | null;
             idempotentReplay: boolean;
-            metric: string;
-            payload: Record<string, unknown>;
         }>;
         getFalsificationQuestions(topicId: string, beliefIds?: string[]): Promise<{
             topicId: string;
-            questions: import("@/lucern/packages/domain-graph/src/graph").GraphFalsificationQuestion[];
+            questions: unknown;
         }>;
     };
     judgments: {
@@ -476,9 +885,9 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             topicId?: string;
             description?: string;
             perspectiveType: import("./workflowClient").WorkflowLensPerspectiveType;
-            promptTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensPromptTemplateReference[];
-            workflowTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensWorkflowTemplate[];
-            taskTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensTaskTemplate[];
+            promptTemplates?: import(".").LensPromptTemplateReference[];
+            workflowTemplates?: import(".").LensWorkflowTemplate[];
+            taskTemplates?: import(".").LensTaskTemplate[];
             filterCriteria?: JsonObject;
         } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").WorkflowLensRecord>>>[0]): Promise<PlatformGatewaySuccess<import("./types").WorkflowLensRecord>>;
         listLenses(query: Parameters<(query: {
@@ -496,8 +905,12 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             lensId: string;
             topicId?: string;
         } & import("./types").TopicIdentifierInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>>[0]): Promise<PlatformGatewaySuccess<import("./types").WorkflowLensBindingRecord>>;
-        create(input: AddWorktreeInput): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesCreateResponse>;
-        add(input: AddWorktreeInput): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesCreateResponse>;
+        create(input: AddWorktreeInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
+        add(input: AddWorktreeInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
         list(query: Parameters<(query: {
             topicId?: string;
             branchId?: string;
@@ -505,18 +918,37 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             track?: string;
             executionBand?: number;
             limit?: number;
-        } & import("./types").TopicIdentifierInput) => Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").WorkflowWorktreeRecord, "worktrees">>>>[0]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesListResponse>;
-        activate(worktreeId: string): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesActivateResponse>;
-        updateMetadata(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesUpdateResponse>;
-        update(input: Parameters<(args: JsonObject, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesUpdateResponse>;
-        updateTargets(input: Parameters<(input: import("./workflowClient").UpdateWorktreeTargetsInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>>[0]): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesTargetsResponse>;
+        } & import("./types").TopicIdentifierInput) => Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").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: import("./workflowClient").UpdateWorktreeTargetsInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>>[0]): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
         listAll(query?: Parameters<(query?: {
             status?: import("./workflowClient").WorkflowWorktreeStatus;
             track?: string;
             executionBand?: number;
             limit?: number;
         }) => Promise<PlatformGatewaySuccess<import("./types").ListWorktreesResponse>>>[0]): Promise<PlatformGatewaySuccess<import("./types").ListWorktreesResponse>>;
-        merge(worktreeId: string, input: MergeInput): Promise<import("@/lucern/packages/client-core/src/worktrees").WorktreesMergeResponse>;
+        merge(worktreeId: string, input: MergeInput): Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>;
         push(worktreeId: string, input: Parameters<(worktreeId: string, input: {
             targetContext: string;
             beliefIds?: string[];
@@ -528,40 +960,94 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             status?: "pending_review" | "changes_requested" | "approved" | "blocked";
         }, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").OpenPullRequestResponse>>>[1]): Promise<PlatformGatewaySuccess<import("./types").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?: import("./topicsClient").TopicListInput) => Promise<PlatformGatewaySuccess<import("./types").TopicListResponse>>>[0]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsListResponse>;
-        compile(topicId: string, input?: Parameters<(topicId: string, input?: import("@/lucern/packages/client-core/src/context").CompileContextInput) => Promise<PlatformGatewaySuccess<import("@/lucern/contracts/context-pack.contract").PublicCompiledContext>>>[1]): Promise<PlatformGatewaySuccess<import("@/lucern/contracts/context-pack.contract").PublicCompiledContext>>;
+        listTopics(query?: Parameters<(query?: import("./topicsClient").TopicListInput) => Promise<PlatformGatewaySuccess<import("./types").TopicListResponse>>>[0]): Promise<PlatformGatewaySuccess<import("./types").TopicListResponse>>;
+        compile(topicId: string, input?: Parameters<(topicId: string, input?: import("./contextTypes").CompileContextInput) => Promise<PlatformGatewaySuccess<import("./contextTypes").PublicCompiledContext>>>[1]): Promise<PlatformGatewaySuccess<import("./contextTypes").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<import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchResult>>;
+        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<import("@/lucern/packages/client-core/src/tasks").TasksCreateResponse>;
-        complete(taskId: string, input: CompleteTaskInput): Promise<import("@/lucern/packages/client-core/src/tasks").TasksCompleteResponse>;
-        update(taskId: string, input: UpdateTaskInput): Promise<import("@/lucern/packages/client-core/src/tasks").TasksUpdateResponse>;
-        list(input: Parameters<(args: JsonObject) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<import("@/lucern/packages/client-core/src/tasks").TasksListResponse>;
+        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?: import("./topicsClient").TopicListInput) => Promise<PlatformGatewaySuccess<import("./types").TopicListResponse>>>[0]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsListResponse>;
-        get(topicId: string): Promise<import("@/lucern/packages/client-core/src/topics").TopicsGetResponse>;
-        create(input: Parameters<(input: import("./topicsClient").TopicCreateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>>[0]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsCreateResponse>;
-        update(topicId: string, input: Parameters<(topicId: string, input: import("./topicsClient").TopicUpdateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>>[1]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsUpdateResponse>;
-        tree(topicId: string, query?: Parameters<(topicId: string, query?: import("./topicsClient").TopicTreeQuery) => Promise<PlatformGatewaySuccess<import("./types").TopicTreeResponse>>>[1]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsTreeResponse>;
+        list(input?: Parameters<(query?: import("./topicsClient").TopicListInput) => Promise<PlatformGatewaySuccess<import("./types").TopicListResponse>>>[0]): Promise<PlatformGatewaySuccess<import("./types").TopicListResponse>>;
+        get(topicId: string): Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>;
+        create(input: Parameters<(input: import("./topicsClient").TopicCreateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>>[0]): Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>;
+        update(topicId: string, input: Parameters<(topicId: string, input: import("./topicsClient").TopicUpdateInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>>[1]): Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>;
+        tree(topicId: string, query?: Parameters<(topicId: string, query?: import("./topicsClient").TopicTreeQuery) => Promise<PlatformGatewaySuccess<import("./types").TopicTreeResponse>>>[1]): Promise<PlatformGatewaySuccess<import("./types").TopicTreeResponse>>;
         getTree(input: {
             rootId: string;
             maxDepth?: number;
-        }): Promise<import("@/lucern/packages/client-core/src/topics").TopicsTreeResponse>;
-        coverage(topicId: string, query?: Parameters<(topicId: string, query?: import("./topicsClient").TopicCoverageQuery) => Promise<PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>>[1]): Promise<import("@/lucern/packages/client-core/src/topics").TopicsCoverageResponse>;
+        }): Promise<PlatformGatewaySuccess<import("./types").TopicTreeResponse>>;
+        coverage(topicId: string, query?: Parameters<(topicId: string, query?: import("./topicsClient").TopicCoverageQuery) => Promise<PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>>[1]): Promise<PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>;
+        remove(topicId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        bulkCreate(input: Parameters<(input: import("./topicsClient").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<import("@/lucern/packages/client-core/src/questions").QuestionsAnswerResponse>;
+        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: {
@@ -572,14 +1058,27 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             topicId?: string;
             severity?: string;
             defeatType?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/contradictions").ContradictionRecord>>;
+        }): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
         list(args: {
             topicId?: string;
             status?: string;
             limit?: number;
             cursor?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/contradictions").ContradictionListResult>>;
-        get(contradictionId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-edges/src/contradictions").ContradictionRecord>>;
+        }): 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;
@@ -600,10 +1099,33 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             tenantId?: string;
             tier?: string;
             status?: string;
-        }): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyListResult>>;
-        get(ontologyId: string): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyRecord>>;
-        bind(input: Parameters<(input: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").BindOntologyInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").BindOntologyInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[0], idempotencyKey?: Parameters<(input: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").BindOntologyInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").BindOntologyInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesBindResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyBindingResult>>;
-        match(input: Parameters<(input: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[0], idempotencyKey?: Parameters<(input: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[0], idempotencyKey?: Parameters<(input: import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchInput, idempotencyKey?: string) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[1]) => Promise<import("@/lucern/packages/client-core/src/ontologies").OntologiesMatchResponse>>[1]): Promise<GatewayDataEnvelope<import("@/lucern/packages/domain-ontologies/src/ontologies").OntologyMatchResult>>;
+        }): Promise<GatewayDataEnvelope<{
+            ontologies: any[];
+            total: number;
+            items: any[];
+            definitions: any[];
+        }>>;
+        get(ontologyId: string): Promise<GatewayDataEnvelope<{
+            [x: string]: unknown;
+        }>>;
+        bind(input: Parameters<(input: import("./ontologyClient").OntologyBindingInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<{
+            [x: string]: unknown;
+        }>>>[0], idempotencyKey?: Parameters<(input: import("./ontologyClient").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>>;
@@ -785,6 +1307,44 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 id?: string;
                 deleted?: boolean;
             }>>;
+            listRolePolicies(query?: import("./coreClient").GatewayScope): Promise<{
+                data: {
+                    policies: import("./policyClient").TenantPolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createRolePolicy(input: import("./coreClient").GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: import("./policyClient").TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: import("./policyClient").TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateRolePolicy(id: string, input: import("./coreClient").GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: import("./policyClient").TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: import("./policyClient").TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteRolePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             checkPermission(query: import("./coreClient").GatewayScope & {
                 topicId?: string;
                 permission?: import("./policyClient").PermissionKind;
@@ -850,6 +1410,11 @@ export declare function createLucernClient(config?: LucernClientConfig): {
     };
     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>>>;
     };
@@ -918,8 +1483,46 @@ export declare function createLucernClient(config?: LucernClientConfig): {
         enable(input: Parameters<(input: import("./packsClient").PackEnableInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
         disable(input: Parameters<(input: import("./packsClient").PackDisableInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<unknown>>>[0]): Promise<PlatformGatewaySuccess<unknown>>;
     };
+    nodes: {
+        list(query: Parameters<(query: import("./graphClient").ListNodesInput) => Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphNode, "nodes">>>>[0]): Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphNode, "nodes">>>;
+        get(input: string | Parameters<(query: import("./graphClient").GetNodeInput) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0]): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+        create(input: Parameters<(input: import("./graphClient").CreateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+        update(input: Parameters<(input: import("./graphClient").UpdateNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<PlatformGraphNode>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+        batchCreate(input: Parameters<(input: import("./graphClient").BatchCreateNodesInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        supersede(input: Parameters<(input: import("./graphClient").SupersedeNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        verify(input: Parameters<(input: import("./graphClient").VerifyNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+        hardDelete(input: Parameters<(input: import("./graphClient").HardDeleteNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>>[0], idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    };
     identity: {
-        whoami(): Promise<import("@/lucern/packages/client-core/src/identity").IdentityWhoamiResponse>;
+        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>;
@@ -928,12 +1531,24 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             createBelief(input: import("./beliefsClient").CreateBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
             modulateConfidence(beliefId: string, input: import("./beliefsClient").ModulateConfidenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").ModulateConfidenceResponse>>;
             forkBelief(beliefId: string, input: import("./beliefsClient").ForkBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").ForkBeliefResponse>>;
+            updateBeliefStatus(input: import("./beliefsClient").UpdateBeliefStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            updateBeliefRationale(input: import("./beliefsClient").UpdateBeliefRationaleInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            linkBeliefs(input: import("./beliefsClient").LinkBeliefsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            unlinkBeliefEvidence(input: import("./beliefsClient").UnlinkBeliefEvidenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            updateBeliefCriticality(input: import("./beliefsClient").UpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            batchUpdateBeliefCriticality(input: import("./beliefsClient").BatchUpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            reassignBeliefsTopic(input: import("./beliefsClient").ReassignBeliefsTopicInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
         };
         graph: {
             listNodes(query: import("./graphClient").ListNodesInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphNode, "nodes">>>;
             queryNodes(query: import("./graphClient").QueryNodesInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphNode, "nodes">>>;
+            getNode(query: import("./graphClient").GetNodeInput): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
             createNode(input: import("./graphClient").CreateNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
             updateNode(input: import("./graphClient").UpdateNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphNode>>;
+            batchCreateNodes(input: import("./graphClient").BatchCreateNodesInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            supersedeNode(input: import("./graphClient").SupersedeNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            verifyNode(input: import("./graphClient").VerifyNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            hardDeleteNode(input: import("./graphClient").HardDeleteNodeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
             listEdges(query: import("./graphClient").ListEdgesInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphEdge, "edges">>>;
             queryEdges(query: import("./graphClient").QueryEdgesInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<PlatformGraphEdge, "edges">>>;
             createEdge(input: import("./graphClient").CreateEdgeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<PlatformGraphEdge>>;
@@ -987,9 +1602,9 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 topicId?: string;
                 description?: string;
                 perspectiveType: import("./workflowClient").WorkflowLensPerspectiveType;
-                promptTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensPromptTemplateReference[];
-                workflowTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensWorkflowTemplate[];
-                taskTemplates?: import("@/lucern/contracts/lens-workflow.contract").LensTaskTemplate[];
+                promptTemplates?: import(".").LensPromptTemplateReference[];
+                workflowTemplates?: import(".").LensWorkflowTemplate[];
+                taskTemplates?: import(".").LensTaskTemplate[];
                 filterCriteria?: JsonObject;
             } & import("./types").TopicIdentifierInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowLensRecord>>;
             applyLensToTopic(input: {
@@ -1020,6 +1635,11 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             merge(worktreeId: string, input: MergeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").MergeWorktreeResponse>>;
             activateWorktree(worktreeId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
             updateWorktreeTargets(input: import("./workflowClient").UpdateWorktreeTargetsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").WorkflowWorktreeRecord>>;
+            completeWorktree(input: import("./workflowClient").CompleteWorktreeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            advanceWorktreePhase(input: import("./workflowClient").AdvanceWorktreePhaseInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            setWorktreePhase(input: import("./workflowClient").SetWorktreePhaseInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            patchWorktreeState(input: import("./workflowClient").PatchWorktreeStateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            bulkCreateWorktrees(input: import("./workflowClient").BulkCreateWorktreesInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
             openPullRequest(worktreeId: string, input: {
                 summary: string;
                 reviewers?: string[];
@@ -1089,11 +1709,13 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 limit?: number;
             }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "workspaces">>>;
             createWorkspace(input: import("./coreClient").GatewayScope & {
-                key: string;
+                workspaceId?: string;
+                key?: string;
                 slug?: string;
-                name: string;
+                name?: string;
                 status?: "active" | "archived";
-                defaultProjectVisibility?: "private" | "firm" | "public";
+                defaultProjectVisibility?: "private" | "team" | "firm" | "external" | "public";
+                restore?: boolean;
                 metadata?: JsonObject;
             }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             listMemberships(query?: import("./coreClient").GatewayScope & {
@@ -1102,26 +1724,169 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 limit?: number;
             }): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "memberships">>>;
             createMembership(input: import("./coreClient").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: import("./coreClient").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: import("./coreClient").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: import("./coreClient").GatewayScope & {
+                status?: "active" | "revoked" | "expired";
+            }): Promise<{
+                data: {
+                    keys: import("./adminClient").TenantApiKeyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createTenantApiKey(input: import("./coreClient").GatewayScope & {
+                label?: string;
+                scopes: string[];
+                expiresAt?: number;
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    key: import("./adminClient").TenantApiKeyRecord | null;
+                    plaintextKey: string | undefined;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            revokeTenantApiKey(keyId: string, input?: import("./coreClient").GatewayScope & {
+                reason?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTenantVaultSecrets(scope: import("./coreClient").GatewayScope): Promise<{
+                data: {
+                    secrets: import("./adminClient").TenantVaultSecretRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createTenantVaultSecret(input: import("./coreClient").GatewayScope & {
+                name: string;
+                description?: string;
+                value: string;
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    secret: import("./adminClient").TenantVaultSecretRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateTenantVaultSecret(secretId: string, input: import("./coreClient").GatewayScope & {
+                name: string;
+                description?: string;
+                value?: string;
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    secret: import("./adminClient").TenantVaultSecretRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteTenantVaultSecret(secretId: string, scope: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listTenantSecrets(scope: import("./coreClient").GatewayScope & {
+                providerId?: string;
+                status?: "active" | "revoked";
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            upsertTenantSecret(input: import("./coreClient").GatewayScope & {
+                providerId: string;
+                apiKey: string;
+                label?: string;
+                modelSlotIds?: string[];
+                passThroughOnly?: boolean;
+                metadata?: JsonObject;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            revokeTenantSecret(secretRef: string, input: import("./coreClient").GatewayScope & {
+                reason?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            getTenantConfig(scope: import("./coreClient").GatewayScope & {
+                tenantId: string;
+            }): Promise<PlatformGatewaySuccess<import("./adminClient").TenantConfigRecord>>;
+            getTenantModelRouting(scope: import("./coreClient").GatewayScope & {
+                tenantId: string;
+            }): Promise<PlatformGatewaySuccess<import("./adminClient").TenantModelRoutingSnapshot>>;
+            upsertTenantConfig(input: import("./coreClient").GatewayScope & Omit<import("./adminClient").TenantConfigRecord, "updatedAt" | "updatedBy">, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./adminClient").TenantConfigRecord>>;
+            listGroups(scope?: import("./coreClient").GatewayScope & {
+                limit?: number;
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            createGroup(input: import("./coreClient").GatewayScope & {
+                name: string;
+                groupKey?: string;
+                groupType?: string;
+                description?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            updateGroup(groupId: string, input: import("./coreClient").GatewayScope & {
+                name?: string;
+                description?: string;
+                workspaceId?: string;
+                clearWorkspaceId?: boolean;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            deleteGroup(groupId: string, input?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listGroupMembers(query: import("./coreClient").GatewayScope & {
+                groupId: string;
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            addGroupMember(input: import("./coreClient").GatewayScope & {
+                groupId: string;
+                principalId: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            removeGroupMember(input: import("./coreClient").GatewayScope & {
+                groupId: string;
+                principalId: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            listPackGroupAssignments(query?: import("./coreClient").GatewayScope & {
+                groupId?: string;
+                status?: string;
+            }): Promise<PlatformGatewaySuccess<unknown>>;
+            assignPackToGroup(input: import("./coreClient").GatewayScope & {
+                groupId: string;
+                packKey: string;
+                packVersion?: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            removePackFromGroup(input: import("./coreClient").GatewayScope & {
+                groupId: string;
+                packKey: string;
+            }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
         };
         identity: {
-            whoami(): Promise<import("@/lucern/packages/client-core/src/identity").IdentityWhoamiResponse>;
+            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?: import("./coreClient").GatewayScope & {
                 status?: string;
                 principalType?: string;
@@ -1182,6 +1947,7 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             revokeKey(keyId: string, input?: {
                 reason?: string;
             }, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            searchClerkUsers(q: string): Promise<PlatformGatewaySuccess<import("./identityClient").ClerkUserSearchResult[]>>;
         };
         policy: {
             listDecisions(query?: import("./coreClient").GatewayScope & {
@@ -1248,6 +2014,44 @@ export declare function createLucernClient(config?: LucernClientConfig): {
                 id?: string;
                 deleted?: boolean;
             }>>;
+            listRolePolicies(query?: import("./coreClient").GatewayScope): Promise<{
+                data: {
+                    policies: import("./policyClient").TenantPolicyRecord[];
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            createRolePolicy(input: import("./coreClient").GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: import("./policyClient").TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: import("./policyClient").TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            updateRolePolicy(id: string, input: import("./coreClient").GatewayScope & {
+                roleName: string;
+                description?: string;
+                permissions: import("./policyClient").TenantPolicyPermission[];
+                groupBindings?: string[];
+            }, idempotencyKey?: string): Promise<{
+                data: {
+                    policy: import("./policyClient").TenantPolicyRecord | null;
+                };
+                success: true;
+                correlationId: string;
+                policyTraceId: string | null;
+                idempotentReplay: boolean;
+            }>;
+            deleteRolePolicy(id: string, scope?: import("./coreClient").GatewayScope, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             checkPermission(query: import("./coreClient").GatewayScope & {
                 topicId?: string;
                 permission?: import("./policyClient").PermissionKind;
@@ -1398,6 +2202,8 @@ export declare function createLucernClient(config?: LucernClientConfig): {
         packs: {
             listCatalog(): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
             getCatalog(): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "catalog">>>;
+            getDiscoveryCatalog(): Promise<PlatformGatewaySuccess<unknown>>;
+            getDiscoveryDetail(packKey: string): Promise<PlatformGatewaySuccess<unknown>>;
             listStates(query?: import("./coreClient").GatewayScope): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
             getStates(query?: import("./coreClient").GatewayScope): Promise<PlatformGatewaySuccess<import("./types").ListResult<any, "states">>>;
             getHealth(packKey: string, query?: import("./coreClient").GatewayScope): Promise<PlatformGatewaySuccess<unknown>>;
@@ -1415,6 +2221,7 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             install(input: import("./packsClient").PackInstallInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             enable(input: import("./packsClient").PackEnableInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             disable(input: import("./packsClient").PackDisableInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            uninstall(input: import("./packsClient").PackUninstallInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             upgrade(input: import("./packsClient").PackUpgradeInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
         };
         reports: {
@@ -1461,6 +2268,7 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             createAgentDefinition(input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             registerAgentDefinition(input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             updateAgentDefinition(agentId: string, input: import("./harnessClient").HarnessAgentWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            invokeManagedAgentDefinition(agentId: string, input: Omit<import("./harnessClient").HarnessInvokeManagedAgentInput, "agentDefinitionId">, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             listAgentRuns(agentId: string, scope?: import("./coreClient").GatewayScope & {
                 status?: string;
                 limit?: number;
@@ -1481,6 +2289,7 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             createToolDefinition(input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             registerToolDefinition(input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
             updateToolDefinition(toolId: string, input: import("./harnessClient").HarnessToolWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<unknown>>;
+            executeToolDefinition(toolId: string, input?: import("./harnessClient").HarnessExecuteToolInput): Promise<PlatformGatewaySuccess<import("./harnessClient").HarnessExecuteToolResult>>;
             listRunEntries(scope?: import("./coreClient").GatewayScope & {
                 status?: string;
                 limit?: number;
@@ -1552,6 +2361,8 @@ export declare function createLucernClient(config?: LucernClientConfig): {
             update(topicId: string, input: import("./topicsClient").TopicUpdateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").TopicRecord>>;
             getTree(topicId: string, query?: import("./topicsClient").TopicTreeQuery): Promise<PlatformGatewaySuccess<import("./types").TopicTreeResponse>>;
             getCoverage(topicId: string, query?: import("./topicsClient").TopicCoverageQuery): Promise<PlatformGatewaySuccess<import("./types").TopicCoverageResponse>>;
+            remove(topicId: string, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+            bulkCreate(input: import("./topicsClient").TopicBulkCreateInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
         };
     };
 };