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

package/src/client.ts

@@ -0,0 +1,2647 @@
+import { type AdminClientConfig, createAdminClient } from "./adminClient";
+import {
+  type AnswersClientConfig,
+  createAnswersClient,
+} from "./answersClient";
+import {
+  type AudiencesClientConfig,
+  createAudiencesClient,
+} from "./audiencesClient";
+import { type AuditClientConfig, createAuditClient } from "./auditClient";
+import {
+  type BeliefsClientConfig,
+  createBeliefsClient,
+} from "./beliefsClient";
+import {
+  createGatewayRequestClient,
+  type GatewayClientConfig,
+  LucernApiError,
+  type PlatformGatewaySuccess,
+  randomIdempotencyKey,
+  toQueryString,
+} from "./coreClient";
+import {
+  type CustomToolRegistration,
+  clearRegisteredCustomTools,
+  invokeRegisteredCustomTool,
+  listRegisteredCustomTools,
+  registerCustomTool,
+  unregisterCustomTool,
+} from "./customTools";
+import {
+  createBeliefsFacade,
+  createContradictionsFacade,
+  createEdgesFacade,
+  createEvidenceFacade,
+  createEventsFacade,
+  createGraphFacade,
+  createIdentityFacade,
+  createOntologiesFacade,
+  createQuestionsFacade,
+  createSearchFacade,
+  createTasksFacade,
+  createTopicsFacade,
+  createWebhooksFacade,
+  createWorktreesFacade,
+} from "./gatewayFacades";
+import {
+  createDecisionsClient,
+  type DecisionsClientConfig,
+  type RecordJudgmentInput,
+} from "./decisionsClient";
+import {
+  createContextClient,
+  type ContextClientConfig,
+} from "./contextClient";
+import { createGraphClient, type GraphClientConfig } from "./graphClient";
+import { createHarnessClient, type HarnessClientConfig } from "./harnessClient";
+import {
+  createIdentityClient,
+  type IdentityClientConfig,
+} from "./identityClient";
+import {
+  createLearningClient,
+  type LearningClientConfig,
+} from "./learningClient";
+import {
+  createMcpParityClient,
+  type McpParityClientConfig,
+} from "./mcpParityClient";
+import {
+  createOntologyClient,
+  type OntologyClientConfig,
+} from "./ontologyClient";
+import { createPacksClient, type PacksClientConfig } from "./packsClient";
+import { createPolicyClient, type PolicyClientConfig } from "./policyClient";
+import { createReportsClient, type ReportsClientConfig } from "./reportsClient";
+import { createSchemaClient, type SchemaClientConfig } from "./schemaClient";
+import { asListItems, resolveText, resolveTopicId } from "./sdkSurface";
+import { createTopicsClient, type TopicsClientConfig } from "./topicsClient";
+import type {
+  JsonObject,
+  PlatformGraphEdge,
+  PlatformGraphNode,
+} from "./types";
+import { LUCERN_SDK_VERSION } from "./version";
+import {
+  type AddWorktreeInput,
+  type CompleteTaskInput,
+  type CreateTaskInput,
+  createWorkflowClient,
+  type MergeInput,
+  type UpdateTaskInput,
+  type WorkflowClientConfig,
+} from "./workflowClient";
+
+type ClientConfig =
+  | BeliefsClientConfig
+  | GraphClientConfig
+  | DecisionsClientConfig
+  | AnswersClientConfig
+  | ContextClientConfig
+  | WorkflowClientConfig
+  | AuditClientConfig
+  | AdminClientConfig
+  | IdentityClientConfig
+  | PolicyClientConfig
+  | PacksClientConfig
+  | ReportsClientConfig
+  | LearningClientConfig
+  | McpParityClientConfig
+  | OntologyClientConfig
+  | HarnessClientConfig
+  | SchemaClientConfig
+  | AudiencesClientConfig
+  | TopicsClientConfig;
+
+type NodeLike = PlatformGraphNode;
+type EdgeLike = PlatformGraphEdge;
+type CustomToolInput = JsonObject;
+type CustomToolInvoker = (input?: CustomToolInput) => Promise<unknown>;
+type CustomToolNamespace = Record<string, CustomToolInvoker>;
+type GatewayDataEnvelope<T extends Record<string, unknown>> =
+  PlatformGatewaySuccess<T> & T;
+
+type BeliefsCompatCreateInput = {
+  topicId?: string;
+  text?: string;
+  canonicalText?: string;
+  formulation?: string;
+  rationale?: string;
+  worktreeId?: string;
+  pillar?: string;
+  sourceBeliefIds?: string[];
+  sourceType?: string;
+  beliefType?: string;
+  reversibility?: string;
+  predictionMeta?: JsonObject;
+  metadata?: JsonObject;
+};
+
+type BeliefsCompatForkInput = {
+  text?: string;
+  newFormulation?: string;
+  formulation?: string;
+  forkReason?:
+    | "refinement"
+    | "contradiction_response"
+    | "scope_change"
+    | "confidence_collapse"
+    | "manual";
+  rationale?: string;
+};
+
+type BeliefsCompatUpdateConfidenceInput = {
+  confidence: number;
+  trigger?:
+    | "evidence_added"
+    | "evidence_removed"
+    | "contradiction_detected"
+    | "contradiction_resolved"
+    | "manual"
+    | "decay"
+    | "agent_assessment"
+    | "merge_outcome"
+    | "worktree_outcome"
+    | "worktree_completed";
+  rationale: string;
+  certainty?: number;
+  maxInlinePropagationTargets?: number;
+};
+
+function asNodeArray(data: unknown): NodeLike[] {
+  const rows = asListItems<NodeLike>(data, "nodes");
+  if (rows.length > 0) {
+    return rows.filter(
+      (value): value is NodeLike => Boolean(value) && typeof value === "object"
+    );
+  }
+  if (data && typeof data === "object") {
+    return [data as NodeLike];
+  }
+  return [];
+}
+
+function asEdgeArray(data: unknown): EdgeLike[] {
+  const rows = asListItems<EdgeLike>(data, "edges");
+  if (rows.length > 0) {
+    return rows.filter(
+      (value): value is EdgeLike => Boolean(value) && typeof value === "object"
+    );
+  }
+  if (data && typeof data === "object") {
+    return [data as EdgeLike];
+  }
+  return [];
+}
+
+function normalizeBeliefStatus(status: string | undefined): string {
+  if (!status) {
+    return "unscored";
+  }
+  if (status === "unscored" || status === "scored" || status === "archived") {
+    return status;
+  }
+  if (status === "active" || status === "in_evaluation") {
+    return "unscored";
+  }
+  if (status === "challenged" || status === "validated") {
+    return "scored";
+  }
+  return "unscored";
+}
+
+function confidenceFromNode(node: NodeLike): number {
+  if (typeof node.confidence === "number") {
+    return node.confidence;
+  }
+  if (typeof node.metadata?.confidence === "number") {
+    return node.metadata.confidence;
+  }
+  return 0;
+}
+
+function toGatewayConfig(config: LucernClientConfig): GatewayClientConfig {
+  return {
+    baseUrl: config.baseUrl,
+    fetchImpl: config.fetchImpl,
+    maxRetries: config.maxRetries,
+    timeoutMs: config.timeoutMs,
+    timeoutMsByMethod: config.timeoutMsByMethod,
+    requestIdFactory: config.requestIdFactory,
+    onRequest: config.onRequest,
+    onResponse: config.onResponse,
+    getAuthHeaders: async () => {
+      const base = (
+        config.getAuthHeaders ? await config.getAuthHeaders() : {}
+      ) as Record<string, string>;
+      if (config.apiKey && !base["x-lucern-key"] && !base.Authorization) {
+        base["x-lucern-key"] = config.apiKey;
+      }
+      if (config.userToken && !base["x-lucern-user-token"]) {
+        base["x-lucern-user-token"] = config.userToken;
+      }
+      if (config.environment && !base["x-lucern-environment"]) {
+        base["x-lucern-environment"] = config.environment;
+      }
+      return base;
+    },
+  };
+}
+
+function requireTopicId(args: { topicId?: string }): string {
+  const topicId = resolveTopicId(args);
+  if (!topicId) {
+    throw new Error("topicId is required");
+  }
+  return topicId;
+}
+
+const AUDIT_NODE_REFERENCE_KEY_PATTERN =
+  /(^|_)(id|nodeid|beliefid|resourceid|targetid|sourceid|subjectid|globalid|entityid|recordid|fromnodeid|tonodeid|linkednodeid|linkedbeliefid|nodeids|beliefids|resourceids)$/i;
+
+function matchesAuditNodeReference(value: unknown, nodeId: string): boolean {
+  if (Array.isArray(value)) {
+    return value.some((entry) => matchesAuditNodeReference(entry, nodeId));
+  }
+
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+
+  return Object.entries(value as Record<string, unknown>).some(([key, entry]) => {
+    if (
+      typeof entry === "string" &&
+      entry === nodeId &&
+      AUDIT_NODE_REFERENCE_KEY_PATTERN.test(key)
+    ) {
+      return true;
+    }
+
+    if (
+      Array.isArray(entry) &&
+      AUDIT_NODE_REFERENCE_KEY_PATTERN.test(key) &&
+      entry.some((item) => item === nodeId)
+    ) {
+      return true;
+    }
+
+    return matchesAuditNodeReference(entry, nodeId);
+  });
+}
+
+function requireText(args: {
+  text?: string;
+  canonicalText?: string;
+  formulation?: string;
+  newFormulation?: string;
+}): string {
+  const text = resolveText(args);
+  if (!text) {
+    throw new Error("text is required");
+  }
+  return text;
+}
+
+function exposeGatewayData<T extends Record<string, unknown>>(
+  response: PlatformGatewaySuccess<T>
+): GatewayDataEnvelope<T> {
+  return Object.assign({}, response, response.data);
+}
+
+/**
+ * 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.
+   * When present, the SDK operates in user-scoped mode with
+   * pack-aware tool filtering. When absent, operates in agent mode.
+   */
+  userToken?: string;
+  /**
+   * Optional pack key for auto-install convenience.
+   * When set, the SDK will call `packs.install()` on first use
+   * to ensure the pack is available in the workspace.
+   */
+  packKey?: string;
+  /** Target environment. Defaults to production if not specified. */
+  environment?: "sandbox" | "production";
+};
+
+/**
+ * Create the high-level Lucern SDK client with all domain namespaces.
+ *
+ * @param config - Client configuration with API key, base URL, and optional settings.
+ * @returns The Lucern client with namespaced methods for beliefs, topics, evidence, decisions, and more.
+ */
+export function createLucernClient(config: LucernClientConfig = {}) {
+  const gatewayConfig = toGatewayConfig(config);
+  const beliefsClient = createBeliefsClient(gatewayConfig);
+  const beliefsFacade = createBeliefsFacade(gatewayConfig);
+  const graphClient = createGraphClient(gatewayConfig);
+  const graphFacade = createGraphFacade(gatewayConfig);
+  const decisionsClient = createDecisionsClient(gatewayConfig);
+  const contextClient = createContextClient(gatewayConfig);
+  const workflowClient = createWorkflowClient(gatewayConfig);
+  const auditClient = createAuditClient(gatewayConfig);
+  const adminClient = createAdminClient(gatewayConfig);
+  const answersClient = createAnswersClient(gatewayConfig);
+  const contradictionsFacade = createContradictionsFacade(gatewayConfig);
+  const edgesFacade = createEdgesFacade(gatewayConfig);
+  const evidenceFacade = createEvidenceFacade(gatewayConfig);
+  const eventsFacade = createEventsFacade(gatewayConfig);
+  const identityClient = createIdentityClient(gatewayConfig);
+  const identityFacade = createIdentityFacade(gatewayConfig);
+  const ontologiesFacade = createOntologiesFacade(gatewayConfig);
+  const questionsFacade = createQuestionsFacade(gatewayConfig);
+  const searchFacade = createSearchFacade(gatewayConfig);
+  const tasksFacade = createTasksFacade(gatewayConfig);
+  const topicsFacade = createTopicsFacade(gatewayConfig);
+  const webhooksFacade = createWebhooksFacade(gatewayConfig);
+  const worktreesFacade = createWorktreesFacade(gatewayConfig);
+  const policyClient = createPolicyClient(gatewayConfig);
+  const ontologyClient = createOntologyClient(gatewayConfig);
+  const mcpParityClient = createMcpParityClient(gatewayConfig);
+  const packsClient = createPacksClient(gatewayConfig);
+  const reportsClient = createReportsClient(gatewayConfig);
+  const learningClient = createLearningClient(gatewayConfig);
+  const harnessClient = createHarnessClient(gatewayConfig);
+  const schemaClient = createSchemaClient(gatewayConfig);
+  const audiencesClient = createAudiencesClient(gatewayConfig);
+  const topicsClient = createTopicsClient(gatewayConfig);
+  const gateway = createGatewayRequestClient(gatewayConfig);
+  const customNamespaceCache = new Map<string, CustomToolNamespace>();
+
+  // Pack auto-install: tracks whether the configured packKey has been installed.
+  // Install is lazy — triggered on first API call or explicit ensurePack().
+  let _packInstalled = !config.packKey; // true if no packKey configured
+  let _packInstallPromise: Promise<void> | null = null;
+
+  async function ensurePack(): Promise<void> {
+    if (_packInstalled) {
+      return;
+    }
+    if (_packInstallPromise) {
+      return _packInstallPromise;
+    }
+
+    const installPromise = (async () => {
+      try {
+        await packsClient.install({
+          packKey: config.packKey!,
+          autoEnable: true,
+        });
+        _packInstalled = true;
+      } catch (err) {
+        // If the pack is already installed, treat as success
+        if (err instanceof LucernApiError && err.code === "ALREADY_EXISTS") {
+          _packInstalled = true;
+          return;
+        }
+        // Re-throw — caller decides whether to proceed without the pack
+        throw err;
+      }
+    })();
+
+    _packInstallPromise = installPromise;
+
+    try {
+      await installPromise;
+    } catch (error) {
+      if (_packInstallPromise === installPromise) {
+        _packInstallPromise = null;
+      }
+      throw error;
+    }
+  }
+
+  const invokeCustomTool = async (
+    fullName: string,
+    input: CustomToolInput = {}
+  ): Promise<unknown> => {
+    const payload =
+      input && typeof input === "object" && !Array.isArray(input) ? input : {};
+    return invokeRegisteredCustomTool(fullName, payload, { source: "sdk" });
+  };
+
+  const getCustomNamespace = (namespace: string): CustomToolNamespace => {
+    const normalized = namespace.trim() || "custom";
+    const cached = customNamespaceCache.get(normalized);
+    if (cached) {
+      return cached;
+    }
+
+    const proxy = new Proxy(
+      {},
+      {
+        get(_target, property): unknown {
+          if (typeof property !== "string" || property === "then") {
+            return;
+          }
+          return async (input: CustomToolInput = {}) =>
+            invokeCustomTool(`${normalized}.${property}`, input);
+        },
+      }
+    ) as CustomToolNamespace;
+
+    customNamespaceCache.set(normalized, proxy);
+    return proxy;
+  };
+
+  const extensionNamespaces = new Proxy(
+    {},
+    {
+      get(_target, namespace): unknown {
+        if (typeof namespace !== "string" || namespace === "then") {
+          return;
+        }
+        return getCustomNamespace(namespace);
+      },
+    }
+  ) as Record<string, CustomToolNamespace>;
+
+  async function createEvidenceCompat(args: {
+    text?: string;
+    canonicalText?: string;
+    topicId?: string;
+    source?: string;
+    sourceUrl?: string;
+    targetId?: string;
+    weight?: number;
+    metadata?: JsonObject;
+    title?: string;
+    content?: string;
+    contentType?: string;
+    kind?: string;
+    supports?: {
+      nodeId: string;
+      weight: number;
+      reasoning?: string;
+    };
+  }) {
+    const topicId = requireTopicId(args);
+    const text = resolveText(args);
+    if (!text) {
+      throw new Error("text is required");
+    }
+    const metadata = {
+      ...(args.metadata ?? {}),
+      ...(args.supports?.reasoning
+        ? { rationale: args.supports.reasoning }
+        : {}),
+    } as JsonObject;
+
+    return evidenceFacade.create({
+      topicId,
+      text,
+      source: args.source ?? args.sourceUrl,
+      targetId: args.targetId ?? args.supports?.nodeId,
+      weight: args.weight ?? args.supports?.weight,
+      metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+      title: args.title,
+      content: args.content,
+      contentType: args.contentType,
+      kind: args.kind,
+    });
+  }
+
+  async function addEvidence(args: {
+    text?: string;
+    canonicalText?: string;
+    topicId?: string;
+    source?: string;
+    sourceUrl?: string;
+    targetId?: string;
+    weight?: number;
+    metadata?: JsonObject;
+    title?: string;
+    content?: string;
+    contentType?: string;
+    kind?: string;
+    supports?: {
+      nodeId: string;
+      weight: number;
+      reasoning?: string;
+    };
+  }) {
+    const created = await createEvidenceCompat({
+      ...args,
+      targetId: args.supports ? undefined : args.targetId,
+      weight: args.supports ? undefined : args.weight,
+    });
+
+    if (!args.supports) {
+      return created.data;
+    }
+
+    const evidenceId = created.data.id;
+    if (typeof evidenceId !== "string" || evidenceId.length === 0) {
+      throw new Error("evidence create did not return an id");
+    }
+
+    const linked = await evidenceFacade.link({
+      evidenceId,
+      targetId: args.supports.nodeId,
+      weight: args.supports.weight,
+      rationale: args.supports.reasoning,
+    });
+
+    return {
+      ...created.data,
+      edgeId: linked.data.edgeId,
+    };
+  }
+
+  async function listBeliefs(args: {
+    topicId?: string;
+    worktreeId?: string;
+    status?: string;
+    minConfidence?: number;
+    limit?: number;
+    cursor?: string;
+  }) {
+    const response = await beliefsFacade.list({
+      topicId: requireTopicId(args),
+      status: args.status,
+      worktreeId: args.worktreeId,
+      minConfidence: args.minConfidence,
+      limit: args.limit,
+      cursor: args.cursor,
+    });
+    return Array.isArray(response.data.beliefs) ? response.data.beliefs : [];
+  }
+
+  async function searchBeliefs(args: {
+    query: string;
+    topicId?: string;
+    status?: string;
+    minConfidence?: number;
+    limit?: number;
+  }) {
+    const topicId = resolveTopicId(args);
+    if (!topicId) {
+      return { results: [] };
+    }
+    const response = await searchFacade.query({
+      q: args.query,
+      topicId,
+      types: ["belief"],
+      status: args.status,
+      minConfidence: args.minConfidence,
+      limit: args.limit,
+    });
+    const data = exposeGatewayData(response);
+    const groupedBeliefs = Array.isArray(data.beliefs)
+      ? (data.beliefs as Record<string, unknown>[])
+      : [];
+    const mergedResults = Array.isArray(data.results)
+      ? (data.results as Record<string, unknown>[])
+      : [];
+    const results =
+      groupedBeliefs.length > 0
+        ? groupedBeliefs
+        : mergedResults.filter((result) => result.type === "belief");
+    return { results };
+  }
+
+  async function searchResources(
+    query: string,
+    options: {
+      topicId?: string;
+      types?: string[];
+      status?: string;
+      minConfidence?: number;
+      limit?: number;
+      cursor?: string;
+    } = {}
+  ) {
+    const topicId = resolveTopicId(options);
+    if (!topicId) {
+      throw new Error("topicId is required");
+    }
+
+    return searchFacade
+      .query({
+        q: query,
+        topicId,
+        types: options.types as Array<"belief" | "evidence" | "question"> | undefined,
+        status: options.status,
+        minConfidence: options.minConfidence,
+        limit: options.limit,
+        cursor: options.cursor,
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function findContradictions(args: {
+    topicId?: string;
+    nodeId?: string;
+    status?: string;
+  }) {
+    const topicId = resolveTopicId(args);
+    const response = topicId
+      ? await graphClient.listNodes({
+          topicId,
+          nodeType: "contradiction",
+          limit: 500,
+        })
+      : args.nodeId
+        ? await graphClient.queryNodes({ nodeId: args.nodeId })
+        : { data: [] };
+    const contradictions = asNodeArray(response.data)
+      .filter((node) => {
+        const status =
+          typeof node.metadata?.status === "string"
+            ? node.metadata.status
+            : typeof node.status === "string"
+              ? node.status
+              : "unresolved";
+        if (args.status && status !== args.status) {
+          return false;
+        }
+        return true;
+      })
+      .map((node) => ({
+        beliefA:
+          typeof node.metadata?.beliefA === "string"
+            ? node.metadata.beliefA
+            : "",
+        beliefB:
+          typeof node.metadata?.beliefB === "string"
+            ? node.metadata.beliefB
+            : "",
+        description: node.canonicalText ?? "",
+        severity:
+          typeof node.metadata?.severity === "string"
+            ? node.metadata.severity
+            : "medium",
+        status:
+          typeof node.metadata?.status === "string"
+            ? node.metadata.status
+            : "unresolved",
+        defeatType:
+          typeof node.metadata?.defeatType === "string"
+            ? node.metadata.defeatType
+            : "rebuts",
+      }));
+    return { contradictions };
+  }
+
+  async function queryLineage(nodeId: string, depth = 5) {
+    const response = await beliefsFacade.lineage(nodeId);
+    const lineage = Array.isArray(response.data.lineage)
+      ? response.data.lineage
+      : [];
+    const chain =
+      lineage.length > 0
+        ? lineage
+            .slice(0, depth + 1)
+            .map((entry, index) => ({
+              nodeId: entry.nodeId ?? entry.beliefId ?? "",
+              relation: index === 0 ? "self" : "ancestor",
+            }))
+        : [{ nodeId, relation: "self" }];
+    return {
+      chain,
+      forkTree: {
+        nodeId,
+        parentCount: Math.max(0, lineage.length - 1),
+        childCount: 0,
+        children: [],
+      },
+      depth,
+      beliefId: response.data.beliefId,
+      lineage,
+    };
+  }
+
+  async function getConfidenceHistory(nodeId: string) {
+    return beliefsFacade.confidenceHistory(nodeId).then(exposeGatewayData);
+  }
+
+  async function getAuditTrail(nodeId: string, limit = 50) {
+    const events = await auditClient.listEvents({ limit });
+    const entries = asListItems<JsonObject>(events.data, "events")
+      .filter((event) => matchesAuditNodeReference(event, nodeId))
+      .slice(0, limit)
+      .map((event) => {
+        const row = event as JsonObject;
+        return {
+          action: typeof row.action === "string" ? row.action : "unknown",
+          actor: typeof row.actor === "string" ? row.actor : "unknown",
+          timestamp:
+            typeof row.timestamp === "number" ? row.timestamp : Date.now(),
+          rationale:
+            typeof row.rationale === "string"
+              ? row.rationale
+              : "No rationale recorded.",
+          before: row.before ?? null,
+          after: row.after ?? null,
+        };
+      });
+    return { entries };
+  }
+
+  async function bisectConfidence(
+    nodeId: string,
+    args: { expectedDirection: "overconfident" | "underconfident" }
+  ) {
+    return beliefsFacade.bisect(nodeId, args).then(exposeGatewayData);
+  }
+
+  async function discoverTopics(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: "/api/platform/v1/context/discover",
+        method: "POST",
+        body: input,
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function discoverEntityConnections(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: "/api/platform/v1/context/entity-connections",
+        method: "POST",
+        body: input,
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function triggerBeliefReview(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: "/api/platform/v1/context/belief-review",
+        method: "POST",
+        body: input,
+        idempotencyKey: randomIdempotencyKey(),
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function createContractCompat(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: "/api/platform/v1/contracts",
+        method: "POST",
+        body: input,
+        idempotencyKey: randomIdempotencyKey(),
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function evaluateContractCompat(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: "/api/platform/v1/contracts/evaluate",
+        method: "POST",
+        body: input,
+        idempotencyKey: randomIdempotencyKey(),
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function getContractStatusCompat(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: "/api/platform/v1/contracts/status",
+        method: "POST",
+        body: input,
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function listContractsCompat(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: `/api/platform/v1/contracts${toQueryString({
+          beliefNodeId:
+            typeof input.beliefNodeId === "string"
+              ? input.beliefNodeId
+              : undefined,
+          contractId:
+            typeof input.contractId === "string" ? input.contractId : undefined,
+          status: typeof input.status === "string" ? input.status : undefined,
+        })}`,
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function createOntologyCompat(input: JsonObject = {}) {
+    const response = await ontologyClient.createDefinition(
+      input as Parameters<typeof ontologyClient.createDefinition>[0]
+    );
+    const envelope = response as PlatformGatewaySuccess<Record<string, unknown>>;
+    return Object.assign({}, envelope, envelope.data);
+  }
+
+  async function updateOntologyCompat(input: JsonObject = {}) {
+    const id = typeof input.id === "string" ? input.id : "";
+    const { id: _id, ...rest } = input;
+    const response = await ontologyClient.updateDefinition(
+      id,
+      rest as Parameters<typeof ontologyClient.updateDefinition>[1]
+    );
+    const envelope = response as PlatformGatewaySuccess<Record<string, unknown>>;
+    return Object.assign({}, envelope, envelope.data);
+  }
+
+  async function archiveOntologyCompat(input: JsonObject = {}) {
+    const id = typeof input.id === "string" ? input.id : "";
+    const response = await ontologyClient.archiveDefinition(id);
+    const envelope = response as PlatformGatewaySuccess<Record<string, unknown>>;
+    return Object.assign({}, envelope, envelope.data);
+  }
+
+  async function createOntologyVersionCompat(input: JsonObject = {}) {
+    const ontologyId =
+      typeof input.ontologyId === "string" ? input.ontologyId : "";
+    const { ontologyId: _ontologyId, ...rest } = input;
+    const response = await ontologyClient.createVersion(
+      ontologyId,
+      rest as Parameters<typeof ontologyClient.createVersion>[1]
+    );
+    const envelope = response as PlatformGatewaySuccess<Record<string, unknown>>;
+    return Object.assign({}, envelope, envelope.data);
+  }
+
+  async function publishOntologyVersionCompat(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: "/api/platform/v1/ontologies/versions/publish",
+        method: "POST",
+        body: input,
+        idempotencyKey: randomIdempotencyKey(),
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function deprecateOntologyVersionCompat(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: "/api/platform/v1/ontologies/versions/deprecate",
+        method: "POST",
+        body: input,
+        idempotencyKey: randomIdempotencyKey(),
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function resolveEffectiveOntologyCompat(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: "/api/platform/v1/ontologies/effective",
+        method: "POST",
+        body: input,
+      })
+      .then(exposeGatewayData);
+  }
+
+  async function traceEntityImpactCompat(input: JsonObject = {}) {
+    return gateway
+      .request<Record<string, unknown>>({
+        path: "/api/platform/v1/graph/trace-entity-impact",
+        method: "POST",
+        body: input,
+      })
+      .then(exposeGatewayData);
+  }
+
+  const nodesNamespace = {
+    list(query: Parameters<typeof graphClient.listNodes>[0]) {
+      return graphClient.listNodes(query);
+    },
+    get(input: string | Parameters<typeof graphClient.getNode>[0]) {
+      return graphClient.getNode(
+        typeof input === "string" ? { nodeId: input } : input
+      );
+    },
+    create(
+      input: Parameters<typeof graphClient.createNode>[0],
+      idempotencyKey?: string
+    ) {
+      return graphClient.createNode(input, idempotencyKey);
+    },
+    update(
+      input: Parameters<typeof graphClient.updateNode>[0],
+      idempotencyKey?: string
+    ) {
+      return graphClient.updateNode(input, idempotencyKey);
+    },
+    batchCreate(
+      input: Parameters<typeof graphClient.batchCreateNodes>[0],
+      idempotencyKey?: string
+    ) {
+      return graphClient.batchCreateNodes(input, idempotencyKey);
+    },
+    supersede(
+      input: Parameters<typeof graphClient.supersedeNode>[0],
+      idempotencyKey?: string
+    ) {
+      return graphClient.supersedeNode(input, idempotencyKey);
+    },
+    verify(
+      input: Parameters<typeof graphClient.verifyNode>[0],
+      idempotencyKey?: string
+    ) {
+      return graphClient.verifyNode(input, idempotencyKey);
+    },
+    hardDelete(
+      input: Parameters<typeof graphClient.hardDeleteNode>[0],
+      idempotencyKey?: string
+    ) {
+      return graphClient.hardDeleteNode(input, idempotencyKey);
+    },
+  };
+
+  return {
+    config,
+    version: LUCERN_SDK_VERSION,
+    search(
+      query: string,
+      options?: {
+        topicId?: string;
+        types?: string[];
+        status?: string;
+        minConfidence?: number;
+        limit?: number;
+        cursor?: string;
+      }
+    ) {
+      return searchResources(query, options);
+    },
+    events: {
+      list(query: Parameters<typeof eventsFacade.list>[0] = {}) {
+        return eventsFacade.list(query).then(exposeGatewayData);
+      },
+      replay(
+        input: Parameters<typeof eventsFacade.replay>[0]
+      ) {
+        return eventsFacade.replay(input).then(exposeGatewayData);
+      },
+    },
+    beliefs: {
+      create(input: BeliefsCompatCreateInput) {
+        return beliefsFacade
+          .create({
+            topicId: requireTopicId(input),
+            text: requireText(input),
+            rationale: input.rationale,
+            worktreeId: input.worktreeId,
+            pillar: input.pillar,
+            sourceBeliefIds: input.sourceBeliefIds,
+            sourceType: input.sourceType,
+            beliefType: input.beliefType,
+            reversibility: input.reversibility,
+            predictionMeta: input.predictionMeta,
+            metadata: input.metadata,
+          })
+          .then(exposeGatewayData);
+      },
+      get(nodeId: string) {
+        return beliefsFacade.get(nodeId).then(exposeGatewayData);
+      },
+      refine(
+        nodeId: string,
+        textOrInput: string | { text: string; rationale?: string },
+        rationale?: string
+      ) {
+        const payload =
+          typeof textOrInput === "string"
+            ? { text: textOrInput, rationale }
+            : {
+                text: textOrInput.text,
+                rationale: textOrInput.rationale,
+              };
+        return beliefsFacade.refine(nodeId, payload).then(exposeGatewayData);
+      },
+      updateConfidence(
+        nodeId: string,
+        input: BeliefsCompatUpdateConfidenceInput
+      ) {
+        return beliefsFacade.updateConfidence(nodeId, input).then(exposeGatewayData);
+      },
+      modulateConfidence(
+        nodeId: string,
+        input: BeliefsCompatUpdateConfidenceInput
+      ) {
+        return beliefsFacade.updateConfidence(nodeId, input).then(exposeGatewayData);
+      },
+      updateStatus(
+        input: Parameters<typeof beliefsFacade.updateStatus>[0],
+        idempotencyKey?: string
+      ) {
+        return beliefsFacade
+          .updateStatus(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      updateRationale(
+        input: Parameters<typeof beliefsFacade.updateRationale>[0],
+        idempotencyKey?: string
+      ) {
+        return beliefsFacade
+          .updateRationale(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      linkBeliefs(
+        input: Parameters<typeof beliefsFacade.linkBeliefs>[0],
+        idempotencyKey?: string
+      ) {
+        return beliefsFacade
+          .linkBeliefs(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      unlinkEvidence(
+        input: Parameters<typeof beliefsFacade.unlinkEvidence>[0],
+        idempotencyKey?: string
+      ) {
+        return beliefsFacade
+          .unlinkEvidence(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      updateCriticality(
+        input: Parameters<typeof beliefsFacade.updateCriticality>[0],
+        idempotencyKey?: string
+      ) {
+        return beliefsFacade
+          .updateCriticality(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      batchUpdateCriticality(
+        input: Parameters<typeof beliefsFacade.batchUpdateCriticality>[0],
+        idempotencyKey?: string
+      ) {
+        return beliefsFacade
+          .batchUpdateCriticality(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      reassignTopic(
+        input: Parameters<typeof beliefsFacade.reassignTopic>[0],
+        idempotencyKey?: string
+      ) {
+        return beliefsFacade
+          .reassignTopic(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      fork(nodeId: string, input: BeliefsCompatForkInput) {
+        return beliefsFacade
+          .fork(nodeId, {
+            text: requireText(input),
+            forkReason: input.forkReason,
+            rationale: input.rationale,
+          })
+          .then(exposeGatewayData);
+      },
+      archive(
+        nodeId: string,
+        input?: string | { reason?: string; rationale?: string }
+      ) {
+        const payload =
+          typeof input === "string"
+            ? { reason: input }
+            : input
+              ? { reason: input.reason ?? input.rationale }
+              : undefined;
+        return beliefsFacade.archive(nodeId, payload).then(exposeGatewayData);
+      },
+      list(args: {
+        topicId?: string;
+        worktreeId?: string;
+        status?: string;
+        minConfidence?: number;
+        limit?: number;
+        cursor?: string;
+      }) {
+        return beliefsFacade
+          .list({
+            topicId: requireTopicId(args),
+            worktreeId: args.worktreeId,
+            status: args.status,
+            minConfidence: args.minConfidence,
+            limit: args.limit,
+            cursor: args.cursor,
+          })
+          .then(exposeGatewayData);
+      },
+      search: searchBeliefs,
+      lineage(nodeId: string) {
+        return beliefsFacade.lineage(nodeId).then(exposeGatewayData);
+      },
+      confidenceHistory(nodeId: string) {
+        return beliefsFacade.confidenceHistory(nodeId).then(exposeGatewayData);
+      },
+      createContract(
+        nodeId: string,
+        input: Parameters<typeof beliefsFacade.createContract>[1]
+      ) {
+        return beliefsFacade
+          .createContract(nodeId, input)
+          .then(exposeGatewayData);
+      },
+      bisect(
+        nodeId: string,
+        input: Parameters<typeof beliefsFacade.bisect>[1]
+      ) {
+        return beliefsFacade.bisect(nodeId, input).then(exposeGatewayData);
+      },
+    },
+    webhooks: {
+      create(input: Parameters<typeof webhooksFacade.create>[0]) {
+        return webhooksFacade.create(input).then(exposeGatewayData);
+      },
+      list(query?: Parameters<typeof webhooksFacade.list>[0]) {
+        return webhooksFacade.list(query).then(exposeGatewayData);
+      },
+      get(id: string) {
+        return webhooksFacade.get(id).then(exposeGatewayData);
+      },
+      update(
+        id: string,
+        input: Parameters<typeof webhooksFacade.update>[1]
+      ) {
+        return webhooksFacade.update(id, input).then(exposeGatewayData);
+      },
+      delete(id: string) {
+        return webhooksFacade.delete(id).then(exposeGatewayData);
+      },
+      test(id: string, input?: Parameters<typeof webhooksFacade.test>[1]) {
+        return webhooksFacade.test(id, input).then(exposeGatewayData);
+      },
+      deliveries(
+        id: string,
+        query?: Parameters<typeof webhooksFacade.deliveries>[1]
+      ) {
+        return webhooksFacade.deliveries(id, query).then(exposeGatewayData);
+      },
+      health(id: string) {
+        return webhooksFacade.health(id).then(exposeGatewayData);
+      },
+    },
+    edges: {
+      create(args: {
+        sourceId: string;
+        targetId: string;
+        edgeType: string;
+        topicId?: string;
+        confidence?: number;
+        weight?: number;
+        context?: string;
+        reasoning?: string;
+      }) {
+        return edgesFacade
+          .create({
+            sourceId: args.sourceId,
+            targetId: args.targetId,
+            edgeType: args.edgeType,
+            topicId: args.topicId,
+            confidence: args.confidence,
+            weight: args.weight,
+            context: args.context ?? args.reasoning,
+          })
+          .then(exposeGatewayData);
+      },
+      update(
+        input: Parameters<typeof edgesFacade.update>[0],
+        idempotencyKey?: string
+      ) {
+        return edgesFacade.update(input, idempotencyKey).then(exposeGatewayData);
+      },
+      remove(
+        input: Parameters<typeof edgesFacade.remove>[0],
+        idempotencyKey?: string
+      ) {
+        return edgesFacade.remove(input, idempotencyKey).then(exposeGatewayData);
+      },
+      removeBetween(
+        input: Parameters<typeof edgesFacade.removeBetween>[0],
+        idempotencyKey?: string
+      ) {
+        return edgesFacade
+          .removeBetween(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      batchCreate(
+        input: Parameters<typeof edgesFacade.batchCreate>[0],
+        idempotencyKey?: string
+      ) {
+        return edgesFacade
+          .batchCreate(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      delete(
+        input: Parameters<typeof edgesFacade.delete>[0],
+        idempotencyKey?: string
+      ) {
+        return edgesFacade.delete(input, idempotencyKey).then(exposeGatewayData);
+      },
+      list(args: {
+        sourceId: string;
+        edgeType?: string;
+        limit?: number;
+        cursor?: string;
+      }) {
+        return edgesFacade
+          .list({
+            sourceId: args.sourceId,
+            edgeType: args.edgeType,
+            limit: args.limit,
+            cursor: args.cursor,
+          })
+          .then(exposeGatewayData);
+      },
+      traverse(args: {
+        startNode: string;
+        direction?: string;
+        maxDepth?: number;
+        topicId?: string;
+      }) {
+        return edgesFacade
+          .traverse({
+            startNode: args.startNode,
+            direction: args.direction,
+            maxDepth: args.maxDepth,
+            topicId: args.topicId,
+          })
+          .then(exposeGatewayData);
+      },
+    },
+    evidence: {
+      create(args: {
+        text?: string;
+        canonicalText?: string;
+        topicId?: string;
+        source?: string;
+        sourceUrl?: string;
+        targetId?: string;
+        weight?: number;
+        metadata?: JsonObject;
+        title?: string;
+        content?: string;
+        contentType?: string;
+        kind?: string;
+        supports?: {
+          nodeId: string;
+          weight: number;
+          reasoning?: string;
+        };
+      }) {
+        return createEvidenceCompat(args).then(exposeGatewayData);
+      },
+      add: addEvidence,
+      get(evidenceId: string) {
+        return evidenceFacade.get(evidenceId).then(exposeGatewayData);
+      },
+      list(args: {
+        topicId?: string;
+        targetId?: string;
+        limit?: number;
+        cursor?: string;
+      }) {
+        return evidenceFacade
+          .list({
+            topicId: args.topicId,
+            targetId: args.targetId,
+            limit: args.limit,
+            cursor: args.cursor,
+          })
+          .then(exposeGatewayData);
+      },
+      search(args: {
+        q?: string;
+        query?: string;
+        topicId?: string;
+        targetId?: string;
+        methodology?: string;
+        limit?: number;
+        cursor?: string;
+      }) {
+        const q = args.q ?? args.query;
+        if (!q) {
+          throw new Error("q is required");
+        }
+        return evidenceFacade
+          .search({
+            q,
+            topicId: args.topicId,
+            targetId: args.targetId,
+            limit: args.limit,
+            cursor: args.cursor,
+          })
+          .then(exposeGatewayData);
+      },
+      link(args: {
+        evidenceId: string;
+        targetId?: string;
+        beliefId?: string;
+        questionId?: string;
+        targetType?: "belief" | "question" | string;
+        weight?: number;
+        rationale?: string;
+      }) {
+        const targetId = args.targetId ?? args.questionId ?? args.beliefId;
+        if (!targetId) {
+          throw new Error("targetId is required");
+        }
+        const targetType =
+          typeof args.targetType === "string"
+            ? args.targetType
+            : args.questionId
+              ? "question"
+              : args.beliefId
+                ? "belief"
+                : undefined;
+        return evidenceFacade
+          .link({
+            evidenceId: args.evidenceId,
+            targetId,
+            targetType: targetType as "belief" | "question" | undefined,
+            weight: args.weight,
+            rationale: args.rationale,
+          })
+          .then(exposeGatewayData);
+      },
+      linkToBelief(args: {
+        evidenceId: string;
+        beliefId: string;
+        weight: number;
+        rationale?: string;
+      }) {
+        return evidenceFacade
+          .link({
+            evidenceId: args.evidenceId,
+            targetId: args.beliefId,
+            weight: args.weight,
+            rationale: args.rationale,
+          })
+          .then((response) => ({
+            ...response.data,
+            beliefId: args.beliefId,
+          }));
+      },
+      updateStatus(
+        input: Parameters<typeof evidenceFacade.updateStatus>[0],
+        idempotencyKey?: string
+      ) {
+        return evidenceFacade
+          .updateStatus(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      update(
+        input: Parameters<typeof evidenceFacade.update>[0],
+        idempotencyKey?: string
+      ) {
+        return evidenceFacade.update(input, idempotencyKey).then(exposeGatewayData);
+      },
+      flagIncorrect(
+        input: Parameters<typeof evidenceFacade.flagIncorrect>[0],
+        idempotencyKey?: string
+      ) {
+        return evidenceFacade
+          .flagIncorrect(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      remove(
+        input: Parameters<typeof evidenceFacade.remove>[0],
+        idempotencyKey?: string
+      ) {
+        return evidenceFacade.remove(input, idempotencyKey).then(exposeGatewayData);
+      },
+      updateVerificationStatus(
+        input: Parameters<typeof evidenceFacade.updateVerificationStatus>[0],
+        idempotencyKey?: string
+      ) {
+        return evidenceFacade
+          .updateVerificationStatus(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+    },
+    questions: {
+      create(args: {
+        text: string;
+        topicId?: string;
+        priority?: string;
+        linkedBeliefId?: string;
+        metadata?: JsonObject;
+      }) {
+        return questionsFacade
+          .create({
+            topicId: requireTopicId(args),
+            text: args.text,
+            priority: args.priority,
+            linkedBeliefId: args.linkedBeliefId,
+            metadata: args.metadata,
+          })
+          .then(exposeGatewayData);
+      },
+      get(questionId: string) {
+        return questionsFacade.get(questionId).then(exposeGatewayData);
+      },
+      refine(
+        questionId: string,
+        text: string,
+        refinementReason?: string
+      ) {
+        return questionsFacade
+          .refine(questionId, {
+            text,
+            rationale: refinementReason,
+          })
+          .then(exposeGatewayData);
+      },
+      list(args: {
+        topicId?: string;
+        status?: string;
+        priority?: string;
+        worktreeId?: string;
+        limit?: number;
+        cursor?: string;
+      }) {
+        return questionsFacade
+          .list({
+            topicId: requireTopicId(args),
+            status: args.status,
+            priority: args.priority,
+            worktreeId: args.worktreeId,
+            limit: args.limit,
+            cursor: args.cursor,
+          })
+          .then(exposeGatewayData);
+      },
+      updateStatus(questionId: string, status: string, rationale?: string) {
+        return questionsFacade
+          .updateStatus(questionId, {
+            status,
+            rationale,
+          })
+          .then(exposeGatewayData);
+      },
+      batchCreate(
+        input: Parameters<typeof questionsFacade.batchCreate>[0],
+        idempotencyKey?: string
+      ) {
+        return questionsFacade
+          .batchCreate(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      add(
+        input: Parameters<typeof questionsFacade.add>[0],
+        idempotencyKey?: string
+      ) {
+        return questionsFacade.add(input, idempotencyKey).then(exposeGatewayData);
+      },
+      updatePriority(
+        input: Parameters<typeof questionsFacade.updatePriority>[0],
+        idempotencyKey?: string
+      ) {
+        return questionsFacade
+          .updatePriority(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      advanceToConviction(
+        input: Parameters<typeof questionsFacade.advanceToConviction>[0],
+        idempotencyKey?: string
+      ) {
+        return questionsFacade
+          .advanceToConviction(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      updateConviction(
+        input: Parameters<typeof questionsFacade.updateConviction>[0],
+        idempotencyKey?: string
+      ) {
+        return questionsFacade
+          .updateConviction(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      finalizeConviction(
+        input: Parameters<typeof questionsFacade.finalizeConviction>[0],
+        idempotencyKey?: string
+      ) {
+        return questionsFacade
+          .finalizeConviction(input, idempotencyKey)
+          .then(exposeGatewayData);
+      },
+      update(
+        input: Parameters<typeof questionsFacade.update>[0],
+        idempotencyKey?: string
+      ) {
+        return questionsFacade.update(input, idempotencyKey).then(exposeGatewayData);
+      },
+      delete(
+        input: Parameters<typeof questionsFacade.delete>[0],
+        idempotencyKey?: string
+      ) {
+        return questionsFacade.delete(input, idempotencyKey).then(exposeGatewayData);
+      },
+      answer(
+        questionId: string,
+        input: {
+          text: string;
+          confidence?: string;
+          evidenceIds?: string[];
+          rationale?: string;
+        }
+      ) {
+        return questionsFacade
+          .answer(questionId, input)
+          .then(exposeGatewayData);
+      },
+      archive(questionId: string, reason?: string) {
+        return questionsFacade
+          .archive(questionId, { reason })
+          .then(exposeGatewayData);
+      },
+      linkEvidence(args: {
+        evidenceId: string;
+        questionId: string;
+        relevance?: number;
+        weight?: number;
+        rationale?: string;
+      }) {
+        const weight = args.weight ?? args.relevance;
+        return evidenceFacade
+          .link({
+            evidenceId: args.evidenceId,
+            targetId: args.questionId,
+            targetType: "question",
+            weight,
+            rationale: args.rationale,
+          })
+          .then((response) => ({
+            ...response.data,
+            questionId: args.questionId,
+            relevance: weight,
+          }));
+      },
+      getHighPriority(args: {
+        topicId?: string;
+        limit?: number;
+        includeAnswered?: boolean;
+      }) {
+        return this.list({
+          topicId: requireTopicId(args),
+          status: args.includeAnswered ? undefined : "open",
+        }).then((data) => {
+          const questions = (
+            Array.isArray(data.questions) ? data.questions : []
+          ) as Array<{ priority?: string } & Record<string, unknown>>;
+          const rank = (priority: string | undefined): number => {
+            switch (priority) {
+              case "urgent":
+                return 4;
+              case "high":
+                return 3;
+              case "medium":
+                return 2;
+              case "low":
+                return 1;
+              default:
+                return 0;
+            }
+          };
+
+          return {
+            questions: [...questions]
+              .sort((a, b) => rank(b.priority) - rank(a.priority))
+              .slice(0, args.limit ?? 20),
+          };
+        });
+      },
+      async findMissing(args: {
+        topicId?: string;
+        minConfidence?: number;
+      }) {
+        return graphFacade
+          .gaps({
+            topicId: requireTopicId(args),
+            minConfidence: args.minConfidence,
+          })
+          .then(exposeGatewayData);
+      },
+    },
+    graph: {
+      nodes: nodesNamespace,
+      createEdge(input: Parameters<typeof graphClient.createEdge>[0]) {
+        return graphClient.createEdge(input);
+      },
+      neighborhood(args: Parameters<typeof graphClient.neighborhood>[0]) {
+        return graphFacade
+          .neighborhood({
+            globalId: args.globalId,
+            globalIds:
+              typeof args.globalIds === "string"
+                ? args.globalIds
+                    .split(",")
+                    .map((value) => value.trim())
+                    .filter((value) => value.length > 0)
+                : undefined,
+            maxDepth: args.maxDepth,
+          })
+          .then(exposeGatewayData);
+      },
+      queryLineage,
+      getConfidenceHistory,
+      getAuditTrail,
+      traverse(args: {
+        startNode: string;
+        direction?: string;
+        maxDepth?: number;
+        topicId?: string;
+      }) {
+        return graphFacade
+          .traverse({
+            startNode: args.startNode,
+            direction: args.direction,
+            maxDepth: args.maxDepth ?? 3,
+            topicId: args.topicId,
+          })
+          .then(exposeGatewayData);
+      },
+      analyze(args: {
+        topicId?: string;
+        limit?: number;
+        metric?: string;
+      }) {
+        return graphFacade
+          .analyze({
+            topicId: requireTopicId(args),
+            limit: args.limit,
+            metric: args.metric as never,
+          })
+          .then(exposeGatewayData);
+      },
+      bias(args: {
+        topicId?: string;
+        threshold?: number;
+        limit?: number;
+      }) {
+        return graphFacade
+          .bias({
+            topicId: requireTopicId(args),
+            threshold: args.threshold,
+            limit: args.limit,
+          })
+          .then(exposeGatewayData);
+      },
+      gaps(args: {
+        topicId?: string;
+        minConfidence?: number;
+      }) {
+        return graphFacade
+          .gaps({
+            topicId: requireTopicId(args),
+            minConfidence: args.minConfidence,
+          })
+          .then(exposeGatewayData);
+      },
+      falsify(args: {
+        topicId?: string;
+        beliefId?: string;
+        beliefIds?: string[];
+        minConfidence?: number;
+      }) {
+        return graphFacade
+          .falsify({
+            topicId: args.topicId,
+            beliefId: args.beliefId,
+            beliefIds: args.beliefIds,
+            minConfidence: args.minConfidence,
+          })
+          .then(exposeGatewayData);
+      },
+      traceEntityImpact(args: { nodeId: string; topicId?: string }) {
+        return traceEntityImpactCompat({
+          nodeId: args.nodeId,
+          topicId: args.topicId,
+        });
+      },
+      searchBeliefs,
+      findContradictions,
+      bisectConfidence,
+      listBeliefs,
+      detectConfirmationBias(
+        topicId: string,
+        threshold?: number
+      ) {
+        return this.bias({
+          topicId,
+          threshold,
+          limit: 200,
+        }).then((response) => ({
+          ...response,
+          topicId,
+          threshold: threshold ?? 0.7,
+        }));
+      },
+      getStructureAnalysis(topicId: string) {
+        return this.analyze({
+          topicId,
+          limit: 200,
+        }).then((response) => ({
+          ...response,
+          topicId,
+        }));
+      },
+      getFalsificationQuestions(
+        topicId: string,
+        beliefIds?: string[]
+      ) {
+        return graphFacade
+          .falsify({
+            topicId,
+            beliefIds,
+          })
+          .then(exposeGatewayData)
+          .then((response) => ({
+            topicId,
+            questions: response.questions,
+          }));
+      },
+    },
+    judgments: {
+      create(input: RecordJudgmentInput) {
+        return decisionsClient.createJudgment(input);
+      },
+      record(input: RecordJudgmentInput) {
+        return decisionsClient.recordJudgment(input);
+      },
+      list(query: Parameters<typeof decisionsClient.listJudgments>[0]) {
+        return decisionsClient.listJudgments(query);
+      },
+      get(judgmentId: string) {
+        return decisionsClient.getJudgment(judgmentId);
+      },
+      recordOutcome(
+        judgmentId: string,
+        input: Parameters<typeof decisionsClient.recordJudgmentOutcome>[1]
+      ) {
+        return decisionsClient.recordJudgmentOutcome(judgmentId, input);
+      },
+      updateOutcome(
+        judgmentId: string,
+        input: Parameters<typeof decisionsClient.updateJudgmentOutcome>[1]
+      ) {
+        return decisionsClient.updateJudgmentOutcome(judgmentId, input);
+      },
+      readiness(topicId: string) {
+        return decisionsClient.getJudgmentReadiness({
+          topicId,
+        });
+      },
+      calibration(topicId: string) {
+        return decisionsClient.getJudgmentCalibration({
+          topicId,
+        });
+      },
+      pendingOutcomeReview(topicId: string) {
+        return decisionsClient.listPendingJudgmentOutcomeReview({
+          topicId,
+        });
+      },
+      transitionAuditIntegrity(args: {
+        topicId?: string;
+        judgmentId?: string;
+        includePassing?: boolean;
+      }) {
+        return decisionsClient.getJudgmentTransitionAuditIntegrity({
+          ...args,
+          topicId: requireTopicId(args),
+        });
+      },
+    },
+    worktrees: {
+      createBranch(input: Parameters<typeof workflowClient.createBranch>[0]) {
+        return workflowClient.createBranch(input);
+      },
+      createLens(input: Parameters<typeof workflowClient.createLens>[0]) {
+        return workflowClient.createLens(input);
+      },
+      listLenses(query: Parameters<typeof workflowClient.listLenses>[0]) {
+        return workflowClient.listLenses(query);
+      },
+      applyLensToTopic(
+        input: Parameters<typeof workflowClient.applyLensToTopic>[0]
+      ) {
+        return workflowClient.applyLensToTopic(input);
+      },
+      removeLensFromTopic(
+        input: Parameters<typeof workflowClient.removeLensFromTopic>[0]
+      ) {
+        return workflowClient.removeLensFromTopic(input);
+      },
+      create(input: AddWorktreeInput) {
+        return worktreesFacade.create({
+          title: input.title,
+          topicId: requireTopicId(input),
+          objective: input.objective,
+          hypothesis: input.hypothesis,
+          beliefIds: input.beliefIds,
+          autoShape: input.autoShape,
+          domainPackId: input.domainPackId,
+          executionOrder: input.executionOrder,
+          dependsOn: input.dependsOn,
+          blocks: input.blocks,
+          gate: input.gate,
+          proofArtifacts: input.proofArtifacts,
+          staffingHint:
+            typeof input.staffingHint === "string"
+              ? input.staffingHint
+              : undefined,
+          lastReconciledAt: input.lastReconciledAt,
+          autoFixPolicy: input.autoFixPolicy,
+        });
+      },
+      add(input: AddWorktreeInput) {
+        return worktreesFacade.create({
+          title: input.title,
+          topicId: requireTopicId(input),
+          objective: input.objective,
+          hypothesis: input.hypothesis,
+          beliefIds: input.beliefIds,
+          autoShape: input.autoShape,
+          domainPackId: input.domainPackId,
+          executionOrder: input.executionOrder,
+          dependsOn: input.dependsOn,
+          blocks: input.blocks,
+          gate: input.gate,
+          proofArtifacts: input.proofArtifacts,
+          staffingHint:
+            typeof input.staffingHint === "string"
+              ? input.staffingHint
+              : undefined,
+          lastReconciledAt: input.lastReconciledAt,
+          autoFixPolicy: input.autoFixPolicy,
+        });
+      },
+      list(query: Parameters<typeof workflowClient.listWorktrees>[0]) {
+        return worktreesFacade.list({
+          topicId: requireTopicId(query),
+          status: query.status,
+          limit: query.limit,
+        });
+      },
+      activate(worktreeId: string) {
+        return worktreesFacade.activate({ id: worktreeId });
+      },
+      updateMetadata(
+        input: Parameters<typeof mcpParityClient.updateWorktreeMetadata>[0]
+      ) {
+        const dependsOn = Array.isArray(input.dependsOn)
+          ? input.dependsOn.filter(
+              (value): value is string => typeof value === "string"
+            )
+          : undefined;
+        const blocks = Array.isArray(input.blocks)
+          ? input.blocks.filter((value): value is string => typeof value === "string")
+          : undefined;
+        return worktreesFacade.update({
+          id: typeof input.worktreeId === "string" ? input.worktreeId : "",
+          hypothesis: typeof input.hypothesis === "string" ? input.hypothesis : undefined,
+          track: typeof input.track === "string" ? input.track : undefined,
+          trackPosition:
+            typeof input.trackPosition === "number" ? input.trackPosition : undefined,
+          executionBand:
+            typeof input.executionBand === "number" ? input.executionBand : undefined,
+          executionOrder:
+            typeof input.executionOrder === "number" ? input.executionOrder : undefined,
+          dependsOn,
+          blocks,
+          gate: typeof input.gate === "string" ? input.gate : undefined,
+        });
+      },
+      update(
+        input: Parameters<typeof mcpParityClient.updateWorktreeMetadata>[0]
+      ) {
+        return this.updateMetadata(input);
+      },
+      updateTargets(
+        input: Parameters<typeof workflowClient.updateWorktreeTargets>[0]
+      ) {
+        return worktreesFacade.updateTargets({
+          id: input.worktreeId,
+          addBeliefIds: input.addBeliefIds,
+          addQuestionIds: input.addQuestionIds,
+          removeBeliefIds: input.removeBeliefIds,
+          removeQuestionIds: input.removeQuestionIds,
+        });
+      },
+      listAll(
+        query: Parameters<typeof workflowClient.listAllWorktrees>[0] = {}
+      ) {
+        return workflowClient.listAllWorktrees(query);
+      },
+      merge(worktreeId: string, input: MergeInput) {
+        return worktreesFacade.merge({
+          id: worktreeId,
+          outcomes: input.outcomes,
+          summary: input.summary,
+        });
+      },
+      push(
+        worktreeId: string,
+        input: Parameters<typeof workflowClient.push>[1]
+      ) {
+        return workflowClient.push(worktreeId, input);
+      },
+      openPullRequest(
+        worktreeId: string,
+        input: Parameters<typeof workflowClient.openPullRequest>[1]
+      ) {
+        return workflowClient.openPullRequest(worktreeId, input);
+      },
+      pipelineSnapshot(topicId: string) {
+        return mcpParityClient.pipelineSnapshot({ topicId });
+      },
+      complete(
+        input: Parameters<typeof worktreesFacade.complete>[0],
+        idempotencyKey?: string
+      ) {
+        return worktreesFacade.complete(input, idempotencyKey);
+      },
+      advancePhase(
+        worktreeId: string,
+        idempotencyKey?: string
+      ) {
+        return worktreesFacade.advancePhase(
+          { worktreeId },
+          idempotencyKey
+        );
+      },
+      setPhase(
+        worktreeId: string,
+        phase: string,
+        idempotencyKey?: string
+      ) {
+        return worktreesFacade.setPhase(
+          { worktreeId, phase },
+          idempotencyKey
+        );
+      },
+      patchState(
+        input: Parameters<typeof worktreesFacade.patchState>[0],
+        idempotencyKey?: string
+      ) {
+        return worktreesFacade.patchState(input, idempotencyKey);
+      },
+      bulkCreate(
+        input: Parameters<typeof worktreesFacade.bulkCreate>[0],
+        idempotencyKey?: string
+      ) {
+        return worktreesFacade.bulkCreate(input, idempotencyKey);
+      },
+    },
+    context: {
+      listTopics(query: Parameters<typeof topicsClient.list>[0] = {}) {
+        return topicsFacade.list({
+          ontologyId: query.ontologyId,
+          parentTopicId: query.parentTopicId,
+          status: query.status as
+            | "active"
+            | "archived"
+            | "watching"
+            | undefined,
+          type: query.type,
+        });
+      },
+      compile(
+        topicId: string,
+        input: Parameters<typeof contextClient.compile>[1] = {}
+      ) {
+        return contextClient.compile(topicId, input);
+      },
+      recordScopeLearning(
+        input: Parameters<typeof mcpParityClient.recordScopeLearning>[0]
+      ) {
+        return mcpParityClient.recordScopeLearning(input);
+      },
+      discover(input: Parameters<typeof mcpParityClient.discover>[0]) {
+        return discoverTopics(input as JsonObject);
+      },
+      analyzeTopicDensity(
+        input: Parameters<typeof mcpParityClient.analyzeTopicDensity>[0]
+      ) {
+        return mcpParityClient.analyzeTopicDensity(input);
+      },
+      applyAutoBranching(
+        input: Parameters<typeof mcpParityClient.applyAutoBranching>[0]
+      ) {
+        return mcpParityClient.applyAutoBranching(input);
+      },
+      seedBeliefLattice(
+        input: Parameters<typeof mcpParityClient.seedBeliefLattice>[0] = {}
+      ) {
+        return mcpParityClient.seedBeliefLattice(input);
+      },
+      getLatticeCoverage(
+        input: Parameters<typeof mcpParityClient.getLatticeCoverage>[0] = {}
+      ) {
+        return mcpParityClient.getLatticeCoverage(input);
+      },
+      matchEntityType(
+        input: Parameters<typeof mcpParityClient.matchEntityType>[0]
+      ) {
+        return ontologiesFacade
+          .match(input as Parameters<typeof ontologiesFacade.match>[0])
+          .then(exposeGatewayData);
+      },
+      discoverEntityConnections(
+        input: Parameters<typeof mcpParityClient.discoverEntityConnections>[0]
+      ) {
+        return discoverEntityConnections(input as JsonObject);
+      },
+      triggerBeliefReview(
+        input: Parameters<typeof mcpParityClient.triggerBeliefReview>[0]
+      ) {
+        return triggerBeliefReview(input as JsonObject);
+      },
+    },
+    tasks: {
+      create(input: CreateTaskInput) {
+        return tasksFacade.create({
+          topicId: requireTopicId(input),
+          title: input.title,
+          description: input.description,
+          taskType: input.taskType,
+          priority: input.priority,
+          linkedBeliefId: input.linkedBeliefId,
+          linkedQuestionId: input.linkedQuestionId,
+          linkedWorktreeId: input.linkedWorktreeId,
+        });
+      },
+      complete(taskId: string, input: CompleteTaskInput) {
+        return tasksFacade.complete({
+          id: taskId,
+          outputSummary: input.outputSummary,
+        });
+      },
+      update(taskId: string, input: UpdateTaskInput) {
+        return tasksFacade.update({
+          id: taskId,
+          title: input.title,
+          description: input.description,
+          priority: input.priority,
+          status: input.status,
+          linkedBeliefId: input.linkedBeliefId,
+          linkedQuestionId: input.linkedQuestionId,
+          linkedWorktreeId: input.linkedWorktreeId,
+        });
+      },
+      list(input: Parameters<typeof mcpParityClient.listTasks>[0]) {
+        return tasksFacade.list({
+          topicId: resolveTopicId(input),
+          worktreeId:
+            typeof input.worktreeId === "string"
+              ? input.worktreeId
+              : typeof input.linkedWorktreeId === "string"
+                ? input.linkedWorktreeId
+                : undefined,
+          status: typeof input.status === "string" ? input.status : undefined,
+          limit: typeof input.limit === "number" ? input.limit : undefined,
+        });
+      },
+    },
+    topics: {
+      list(input: Parameters<typeof topicsClient.list>[0] = {}) {
+        return topicsFacade.list({
+          ontologyId: input.ontologyId,
+          parentTopicId: input.parentTopicId,
+          status: input.status as "active" | "archived" | "watching" | undefined,
+          type: input.type,
+        });
+      },
+      get(topicId: string) {
+        return topicsFacade.get(topicId);
+      },
+      create(input: Parameters<typeof topicsClient.create>[0]) {
+        return topicsFacade.create({
+          name: input.name,
+          description: input.description,
+          type: input.type,
+          parentTopicId: input.parentTopicId,
+          ontologyId: input.ontologyId,
+          tenantId: input.tenantId,
+          workspaceId: input.workspaceId,
+          visibility: input.visibility,
+          createdBy: input.createdBy,
+        });
+      },
+      update(
+        topicId: string,
+        input: Parameters<typeof topicsClient.update>[1]
+      ) {
+        return topicsFacade.update({
+          id: topicId,
+          name: input.name,
+          description: input.description,
+          type: input.type,
+          ontologyId: input.ontologyId,
+          clearOntologyId: input.clearOntologyId,
+          status: input.status,
+          visibility: input.visibility,
+        });
+      },
+      tree(
+        topicId: string,
+        query: Parameters<typeof topicsClient.getTree>[1] = {}
+      ) {
+        return topicsFacade.tree({
+          id: topicId,
+          maxDepth: query.maxDepth,
+        });
+      },
+      getTree(input: { rootId: string; maxDepth?: number }) {
+        return topicsFacade.tree({
+          id: input.rootId,
+          maxDepth: input.maxDepth,
+        });
+      },
+      coverage(
+        topicId: string,
+        query: Parameters<typeof topicsClient.getCoverage>[1] = {}
+      ) {
+        return topicsFacade.coverage({
+          id: topicId,
+          includeDescendants: query.includeDescendants,
+          maxDepth: query.maxDepth,
+        });
+      },
+      remove(topicId: string, idempotencyKey?: string) {
+        return topicsFacade.remove(topicId, idempotencyKey);
+      },
+      bulkCreate(
+        input: Parameters<typeof topicsFacade.bulkCreate>[0],
+        idempotencyKey?: string
+      ) {
+        return topicsFacade.bulkCreate(input, idempotencyKey);
+      },
+    },
+    answers: {
+      create(input: Parameters<typeof mcpParityClient.createAnswer>[0]) {
+        const questionId =
+          typeof input.questionNodeId === "string" ? input.questionNodeId : "";
+        if (!questionId) {
+          throw new Error("questionNodeId is required");
+        }
+        const text =
+          typeof input.answerText === "string" ? input.answerText : "";
+        if (!text) {
+          throw new Error("answerText is required");
+        }
+        const confidence =
+          input.confidence === "moderate" ? "medium" : input.confidence;
+
+        return questionsFacade.answer(questionId, {
+          text,
+          confidence:
+            typeof confidence === "string" ? confidence : undefined,
+          evidenceIds: Array.isArray(input.evidenceNodeIds)
+            ? input.evidenceNodeIds.filter(
+                (value): value is string => typeof value === "string"
+              )
+            : undefined,
+        });
+      },
+      get(input: Parameters<typeof mcpParityClient.getAnswer>[0]) {
+        const questionId =
+          typeof input.questionNodeId === "string" ? input.questionNodeId : "";
+        if (!questionId) {
+          throw new Error("questionNodeId is required");
+        }
+        return answersClient.get(questionId);
+      },
+    },
+    contradictions: {
+      flag(args: {
+        beliefA: string;
+        beliefB: string;
+        description: string;
+        topicId?: string;
+        severity?: string;
+        defeatType?: string;
+      }) {
+        return contradictionsFacade
+          .flag({
+            beliefA: args.beliefA,
+            beliefB: args.beliefB,
+            description: args.description,
+            topicId: requireTopicId(args),
+            severity: args.severity,
+            defeatType: args.defeatType,
+          })
+          .then(exposeGatewayData);
+      },
+      list(args: {
+        topicId?: string;
+        status?: string;
+        limit?: number;
+        cursor?: string;
+      }) {
+        return contradictionsFacade
+          .list({
+            topicId: requireTopicId(args),
+            status: args.status,
+            limit: args.limit,
+            cursor: args.cursor,
+          })
+          .then(exposeGatewayData);
+      },
+      get(contradictionId: string) {
+        return contradictionsFacade.get(contradictionId).then(exposeGatewayData);
+      },
+      find: findContradictions,
+    },
+    ontologies: {
+      list(
+        input: {
+          tenantId?: string;
+          tier?: string;
+          status?: string;
+        } = {}
+      ) {
+        return ontologiesFacade.list(input).then(exposeGatewayData);
+      },
+      get(ontologyId: string) {
+        return ontologiesFacade
+          .get(ontologyId)
+          .then((response) => exposeGatewayData(response));
+      },
+      bind(
+        input: Parameters<typeof ontologiesFacade.bind>[0],
+        idempotencyKey?: Parameters<typeof ontologiesFacade.bind>[1]
+      ) {
+        return ontologiesFacade
+          .bind(input, idempotencyKey)
+          .then((response) => exposeGatewayData(response));
+      },
+      match(
+        input: Parameters<typeof ontologiesFacade.match>[0],
+        idempotencyKey?: Parameters<typeof ontologiesFacade.match>[1]
+      ) {
+        return ontologiesFacade.match(input, idempotencyKey).then(exposeGatewayData);
+      },
+      create(input: Parameters<typeof mcpParityClient.createOntology>[0]) {
+        return createOntologyCompat(input as JsonObject);
+      },
+      update(input: Parameters<typeof mcpParityClient.updateOntology>[0]) {
+        return updateOntologyCompat(input as JsonObject);
+      },
+      archive(input: Parameters<typeof mcpParityClient.archiveOntology>[0]) {
+        return archiveOntologyCompat(input as JsonObject);
+      },
+      createVersion(
+        input: Parameters<typeof mcpParityClient.createOntologyVersion>[0]
+      ) {
+        return createOntologyVersionCompat(input as JsonObject);
+      },
+      publishVersion(
+        input: Parameters<typeof mcpParityClient.publishOntologyVersion>[0]
+      ) {
+        return publishOntologyVersionCompat(input as JsonObject);
+      },
+      deprecateVersion(
+        input: Parameters<typeof mcpParityClient.deprecateOntologyVersion>[0]
+      ) {
+        return deprecateOntologyVersionCompat(input as JsonObject);
+      },
+      resolveEffective(
+        input: Parameters<typeof mcpParityClient.resolveEffectiveOntology>[0]
+      ) {
+        return resolveEffectiveOntologyCompat(input as JsonObject);
+      },
+      raw: ontologyClient,
+    },
+    coordination: {
+      registerSession(
+        input: Parameters<typeof mcpParityClient.registerSession>[0] = {}
+      ) {
+        return mcpParityClient.registerSession(input);
+      },
+      heartbeatSession(
+        input: Parameters<typeof mcpParityClient.heartbeatSession>[0] = {}
+      ) {
+        return mcpParityClient.heartbeatSession(input);
+      },
+      endSession(
+        input: Parameters<typeof mcpParityClient.endSession>[0] = {}
+      ) {
+        return mcpParityClient.endSession(input);
+      },
+      listActiveSessions(
+        input: Parameters<typeof mcpParityClient.listActiveSessions>[0] = {}
+      ) {
+        return mcpParityClient.listActiveSessions(input);
+      },
+      sendAgentMessage(
+        input: Parameters<typeof mcpParityClient.sendAgentMessage>[0]
+      ) {
+        return mcpParityClient.sendAgentMessage(input);
+      },
+      broadcastMessage(
+        input: Parameters<typeof mcpParityClient.broadcastMessage>[0]
+      ) {
+        return mcpParityClient.broadcastMessage(input);
+      },
+      getInbox(
+        input: Parameters<typeof mcpParityClient.getAgentInbox>[0] = {}
+      ) {
+        return mcpParityClient.getAgentInbox(input);
+      },
+      claimFiles(input: Parameters<typeof mcpParityClient.claimFiles>[0]) {
+        return mcpParityClient.claimFiles(input);
+      },
+    },
+    policy: {
+      checkPermission(
+        input: Parameters<typeof mcpParityClient.checkPermission>[0]
+      ) {
+        return policyClient.checkPermission({
+          topicId: typeof input.topicId === "string" ? input.topicId : undefined,
+          permission:
+            typeof input.permission === "string"
+              ? (input.permission as "read" | "write")
+              : undefined,
+          principal:
+            typeof input.principal === "string" ? input.principal : undefined,
+          principalId:
+            typeof input.principalId === "string" ? input.principalId : undefined,
+          beliefClusterId:
+            typeof input.beliefClusterId === "string"
+              ? input.beliefClusterId
+              : undefined,
+        });
+      },
+      listAccessibleTopics(
+        input: Parameters<typeof policyClient.listAccessibleTopics>[0] = {}
+      ) {
+        return policyClient.listAccessibleTopics({
+          permission:
+            typeof input.permission === "string"
+              ? (input.permission as "read" | "write")
+              : undefined,
+          includeShared:
+            typeof input.includeShared === "boolean"
+              ? input.includeShared
+              : undefined,
+          principal:
+            typeof input.principal === "string" ? input.principal : undefined,
+          principalId:
+            typeof input.principalId === "string" ? input.principalId : undefined,
+          limit: typeof input.limit === "number" ? input.limit : undefined,
+        });
+      },
+      filterByPermission(
+        input: Parameters<typeof mcpParityClient.filterByPermission>[0]
+      ) {
+        return policyClient.filterByPermission({
+          topicIds: Array.isArray(input.topicIds)
+            ? input.topicIds.filter(
+                (value): value is string => typeof value === "string"
+              )
+            : undefined,
+          permission:
+            typeof input.permission === "string"
+              ? (input.permission as "read" | "write")
+              : undefined,
+          principal:
+            typeof input.principal === "string" ? input.principal : undefined,
+          principalId:
+            typeof input.principalId === "string" ? input.principalId : undefined,
+        });
+      },
+      manageWritePolicy(
+        input: Parameters<typeof mcpParityClient.manageWritePolicy>[0]
+      ) {
+        return mcpParityClient.manageWritePolicy(input);
+      },
+      raw: policyClient,
+    },
+    observations: {
+      ingest(input: Parameters<typeof mcpParityClient.ingestObservation>[0]) {
+        return mcpParityClient.ingestObservation(input);
+      },
+      getContext(
+        input: Parameters<typeof mcpParityClient.getObservationContext>[0]
+      ) {
+        return mcpParityClient.getObservationContext(input);
+      },
+    },
+    coding: {
+      getCodeContext(input: Parameters<typeof mcpParityClient.getCodeContext>[0]) {
+        return mcpParityClient.getCodeContext(input);
+      },
+      getChangeHistory(
+        input: Parameters<typeof mcpParityClient.getChangeHistory>[0]
+      ) {
+        return mcpParityClient.getChangeHistory(input);
+      },
+      recordAttempt(input: Parameters<typeof mcpParityClient.recordAttempt>[0]) {
+        return mcpParityClient.recordAttempt(input);
+      },
+      getFailureLog(input: Parameters<typeof mcpParityClient.getFailureLog>[0]) {
+        return mcpParityClient.getFailureLog(input);
+      },
+    },
+    contracts: {
+      create(
+        input: Parameters<typeof mcpParityClient.createEpistemicContract>[0]
+      ) {
+        return createContractCompat(input as JsonObject);
+      },
+      list(
+        input: {
+          beliefNodeId?: string;
+          contractId?: string;
+          status?: string;
+        } = {}
+      ) {
+        return listContractsCompat(input as JsonObject);
+      },
+      evaluate(input: Parameters<typeof mcpParityClient.evaluateContract>[0]) {
+        return evaluateContractCompat(input as JsonObject);
+      },
+      getStatus(input: Parameters<typeof mcpParityClient.getContractStatus>[0]) {
+        return getContractStatusCompat(input as JsonObject);
+      },
+    },
+    bootstrap: {
+      generateSessionHandoff(
+        input: Parameters<typeof mcpParityClient.generateSessionHandoff>[0]
+      ) {
+        return mcpParityClient.generateSessionHandoff(input);
+      },
+    },
+    research: {
+      searchSources(args: {
+        query: string;
+        topicId?: string;
+        sources?: string[];
+      }) {
+        const topicId = requireTopicId(args);
+        return graphClient
+          .listNodes({
+            topicId,
+            nodeType: "source",
+            limit: 100,
+          })
+          .then((response) => {
+            const query = args.query.toLowerCase();
+            const results = asNodeArray(response.data)
+              .filter((node) => {
+                const text = `${node.canonicalText ?? ""} ${
+                  typeof node.metadata?.title === "string"
+                    ? node.metadata.title
+                    : ""
+                }`.toLowerCase();
+                if (!text.includes(query)) {
+                  return false;
+                }
+                if (!args.sources || args.sources.length === 0) {
+                  return true;
+                }
+                const sourceType =
+                  typeof node.metadata?.sourceType === "string"
+                    ? node.metadata.sourceType.toLowerCase()
+                    : "";
+                return args.sources.some((source) =>
+                  sourceType.includes(source.toLowerCase())
+                );
+              })
+              .map((node) => ({
+                title:
+                  typeof node.metadata?.title === "string"
+                    ? node.metadata.title
+                    : (node.canonicalText ?? "Untitled source"),
+                url:
+                  typeof node.metadata?.sourceUrl === "string"
+                    ? node.metadata.sourceUrl
+                    : "",
+                snippet: node.canonicalText ?? "",
+                relevanceScore: 1,
+                suggestedEvidence: node.canonicalText ?? "",
+              }));
+            return { results };
+          });
+      },
+      async executeDeepResearch(args: {
+        query: string;
+        topicId?: string;
+        depth?: "quick" | "standard" | "deep";
+      }) {
+        const sources = await this.searchSources({
+          query: args.query,
+          topicId: requireTopicId(args),
+          sources: ["web"],
+        });
+        const sampleSize =
+          args.depth === "deep" ? 10 : args.depth === "quick" ? 3 : 5;
+        const selected = sources.results.slice(0, sampleSize);
+        return {
+          report: {
+            summary:
+              selected.length > 0
+                ? `Research completed for "${args.query}" with ${selected.length} relevant sources.`
+                : `No relevant sources found for "${args.query}".`,
+            findings: selected.map((source) => ({
+              title: source.title,
+              summary: source.snippet,
+              sourceUrl: source.url,
+            })),
+            sources: selected.map((source) => ({
+              title: source.title,
+              url: source.url,
+            })),
+            linkedEvidence: [],
+            linkedQuestions: [],
+          },
+        };
+      },
+    },
+    tools: {
+      register(registration: CustomToolRegistration) {
+        return registerCustomTool(registration);
+      },
+      unregister(fullName: string) {
+        return unregisterCustomTool(fullName);
+      },
+      list() {
+        return listRegisteredCustomTools();
+      },
+      clear() {
+        clearRegisteredCustomTools();
+      },
+      invoke(name: string, input: CustomToolInput = {}) {
+        const fullName = name.includes(".") ? name : `custom.${name}`;
+        return invokeCustomTool(fullName, input);
+      },
+      namespace(namespace: string) {
+        return getCustomNamespace(namespace);
+      },
+    },
+    packs: {
+      /**
+       * Ensure the configured packKey is installed.
+       * No-op if no packKey was provided or if the pack is already installed.
+       * Called automatically on first API use when packKey is set.
+       */
+      ensurePack,
+      /**
+       * Check if the configured pack has been installed in this session.
+       */
+      get isInstalled() {
+        return _packInstalled;
+      },
+      listCatalog() {
+        return packsClient.listCatalog();
+      },
+      catalog() {
+        return packsClient.getCatalog();
+      },
+      listStates(scope?: Parameters<typeof packsClient.listStates>[0]) {
+        return packsClient.listStates(scope);
+      },
+      states(scope?: Parameters<typeof packsClient.getStates>[0]) {
+        return packsClient.getStates(scope);
+      },
+      install(input: Parameters<typeof packsClient.install>[0]) {
+        return packsClient.install(input);
+      },
+      enable(input: Parameters<typeof packsClient.enable>[0]) {
+        return packsClient.enable(input);
+      },
+      disable(input: Parameters<typeof packsClient.disable>[0]) {
+        return packsClient.disable(input);
+      },
+    },
+    nodes: nodesNamespace,
+    identity: identityFacade,
+    custom: getCustomNamespace("custom"),
+    extensions: extensionNamespaces,
+    raw: {
+      beliefs: beliefsClient,
+      graph: graphClient,
+      decisions: decisionsClient,
+      workflow: workflowClient,
+      audit: auditClient,
+      admin: adminClient,
+      identity: identityClient,
+      policy: policyClient,
+      answers: answersClient,
+      ontology: ontologyClient,
+      mcpParity: mcpParityClient,
+      packs: packsClient,
+      reports: reportsClient,
+      learning: learningClient,
+      harness: harnessClient,
+      schema: schemaClient,
+      audiences: audiencesClient,
+      topics: topicsClient,
+    },
+  };
+}