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

package/src/client.ts

@@ -1,2647 +0,0 @@
-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,
-    },
-  };
-}