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

package/dist/lib/platform/sdk/client.js

@@ -1,1831 +0,0 @@
-import { createAdminClient } from "./adminClient.js";
-import { createAnswersClient, } from "./answersClient.js";
-import { createAudiencesClient, } from "./audiencesClient.js";
-import { createAuditClient } from "./auditClient.js";
-import { createBeliefsClient, } from "./beliefsClient.js";
-import { createGatewayRequestClient, LucernApiError, randomIdempotencyKey, toQueryString, } from "./coreClient.js";
-import { clearRegisteredCustomTools, invokeRegisteredCustomTool, listRegisteredCustomTools, registerCustomTool, unregisterCustomTool, } from "./customTools.js";
-import { createBeliefsFacade, createContradictionsFacade, createEdgesFacade, createEvidenceFacade, createEventsFacade, createGraphFacade, createIdentityFacade, createOntologiesFacade, createQuestionsFacade, createSearchFacade, createTasksFacade, createTopicsFacade, createWebhooksFacade, createWorktreesFacade, } from "./gatewayFacades.js";
-import { createDecisionsClient, } from "./decisionsClient.js";
-import { createContextClient, } from "./contextClient.js";
-import { createGraphClient } from "./graphClient.js";
-import { createHarnessClient } from "./harnessClient.js";
-import { createIdentityClient, } from "./identityClient.js";
-import { createLearningClient, } from "./learningClient.js";
-import { createMcpParityClient, } from "./mcpParityClient.js";
-import { createOntologyClient, } from "./ontologyClient.js";
-import { createPacksClient } from "./packsClient.js";
-import { createPolicyClient } from "./policyClient.js";
-import { createReportsClient } from "./reportsClient.js";
-import { createSchemaClient } from "./schemaClient.js";
-import { asListItems, resolveText, resolveTopicId } from "./sdkSurface.js";
-import { createTopicsClient } from "./topicsClient.js";
-import { LUCERN_SDK_VERSION } from "./version.js";
-import { createWorkflowClient, } from "./workflowClient.js";
-function asNodeArray(data) {
-    const rows = asListItems(data, "nodes");
-    if (rows.length > 0) {
-        return rows.filter((value) => Boolean(value) && typeof value === "object");
-    }
-    if (data && typeof data === "object") {
-        return [data];
-    }
-    return [];
-}
-function asEdgeArray(data) {
-    const rows = asListItems(data, "edges");
-    if (rows.length > 0) {
-        return rows.filter((value) => Boolean(value) && typeof value === "object");
-    }
-    if (data && typeof data === "object") {
-        return [data];
-    }
-    return [];
-}
-function normalizeBeliefStatus(status) {
-    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) {
-    if (typeof node.confidence === "number") {
-        return node.confidence;
-    }
-    if (typeof node.metadata?.confidence === "number") {
-        return node.metadata.confidence;
-    }
-    return 0;
-}
-function toGatewayConfig(config) {
-    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() : {});
-            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) {
-    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, nodeId) {
-    if (Array.isArray(value)) {
-        return value.some((entry) => matchesAuditNodeReference(entry, nodeId));
-    }
-    if (!value || typeof value !== "object") {
-        return false;
-    }
-    return Object.entries(value).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) {
-    const text = resolveText(args);
-    if (!text) {
-        throw new Error("text is required");
-    }
-    return text;
-}
-function exposeGatewayData(response) {
-    return Object.assign({}, response, response.data);
-}
-/**
- * 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 = {}) {
-    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();
-    // 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 = null;
-    async function ensurePack() {
-        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, input = {}) => {
-        const payload = input && typeof input === "object" && !Array.isArray(input) ? input : {};
-        return invokeRegisteredCustomTool(fullName, payload, { source: "sdk" });
-    };
-    const getCustomNamespace = (namespace) => {
-        const normalized = namespace.trim() || "custom";
-        const cached = customNamespaceCache.get(normalized);
-        if (cached) {
-            return cached;
-        }
-        const proxy = new Proxy({}, {
-            get(_target, property) {
-                if (typeof property !== "string" || property === "then") {
-                    return;
-                }
-                return async (input = {}) => invokeCustomTool(`${normalized}.${property}`, input);
-            },
-        });
-        customNamespaceCache.set(normalized, proxy);
-        return proxy;
-    };
-    const extensionNamespaces = new Proxy({}, {
-        get(_target, namespace) {
-            if (typeof namespace !== "string" || namespace === "then") {
-                return;
-            }
-            return getCustomNamespace(namespace);
-        },
-    });
-    async function createEvidenceCompat(args) {
-        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 }
-                : {}),
-        };
-        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) {
-        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) {
-        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) {
-        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
-            : [];
-        const mergedResults = Array.isArray(data.results)
-            ? data.results
-            : [];
-        const results = groupedBeliefs.length > 0
-            ? groupedBeliefs
-            : mergedResults.filter((result) => result.type === "belief");
-        return { results };
-    }
-    async function searchResources(query, options = {}) {
-        const topicId = resolveTopicId(options);
-        if (!topicId) {
-            throw new Error("topicId is required");
-        }
-        return searchFacade
-            .query({
-            q: query,
-            topicId,
-            types: options.types,
-            status: options.status,
-            minConfidence: options.minConfidence,
-            limit: options.limit,
-            cursor: options.cursor,
-        })
-            .then(exposeGatewayData);
-    }
-    async function findContradictions(args) {
-        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, 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) {
-        return beliefsFacade.confidenceHistory(nodeId).then(exposeGatewayData);
-    }
-    async function getAuditTrail(nodeId, limit = 50) {
-        const events = await auditClient.listEvents({ limit });
-        const entries = asListItems(events.data, "events")
-            .filter((event) => matchesAuditNodeReference(event, nodeId))
-            .slice(0, limit)
-            .map((event) => {
-            const row = event;
-            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, args) {
-        return beliefsFacade.bisect(nodeId, args).then(exposeGatewayData);
-    }
-    async function discoverTopics(input = {}) {
-        return gateway
-            .request({
-            path: "/api/platform/v1/context/discover",
-            method: "POST",
-            body: input,
-        })
-            .then(exposeGatewayData);
-    }
-    async function discoverEntityConnections(input = {}) {
-        return gateway
-            .request({
-            path: "/api/platform/v1/context/entity-connections",
-            method: "POST",
-            body: input,
-        })
-            .then(exposeGatewayData);
-    }
-    async function triggerBeliefReview(input = {}) {
-        return gateway
-            .request({
-            path: "/api/platform/v1/context/belief-review",
-            method: "POST",
-            body: input,
-            idempotencyKey: randomIdempotencyKey(),
-        })
-            .then(exposeGatewayData);
-    }
-    async function createContractCompat(input = {}) {
-        return gateway
-            .request({
-            path: "/api/platform/v1/contracts",
-            method: "POST",
-            body: input,
-            idempotencyKey: randomIdempotencyKey(),
-        })
-            .then(exposeGatewayData);
-    }
-    async function evaluateContractCompat(input = {}) {
-        return gateway
-            .request({
-            path: "/api/platform/v1/contracts/evaluate",
-            method: "POST",
-            body: input,
-            idempotencyKey: randomIdempotencyKey(),
-        })
-            .then(exposeGatewayData);
-    }
-    async function getContractStatusCompat(input = {}) {
-        return gateway
-            .request({
-            path: "/api/platform/v1/contracts/status",
-            method: "POST",
-            body: input,
-        })
-            .then(exposeGatewayData);
-    }
-    async function listContractsCompat(input = {}) {
-        return gateway
-            .request({
-            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 = {}) {
-        const response = await ontologyClient.createDefinition(input);
-        const envelope = response;
-        return Object.assign({}, envelope, envelope.data);
-    }
-    async function updateOntologyCompat(input = {}) {
-        const id = typeof input.id === "string" ? input.id : "";
-        const { id: _id, ...rest } = input;
-        const response = await ontologyClient.updateDefinition(id, rest);
-        const envelope = response;
-        return Object.assign({}, envelope, envelope.data);
-    }
-    async function archiveOntologyCompat(input = {}) {
-        const id = typeof input.id === "string" ? input.id : "";
-        const response = await ontologyClient.archiveDefinition(id);
-        const envelope = response;
-        return Object.assign({}, envelope, envelope.data);
-    }
-    async function createOntologyVersionCompat(input = {}) {
-        const ontologyId = typeof input.ontologyId === "string" ? input.ontologyId : "";
-        const { ontologyId: _ontologyId, ...rest } = input;
-        const response = await ontologyClient.createVersion(ontologyId, rest);
-        const envelope = response;
-        return Object.assign({}, envelope, envelope.data);
-    }
-    async function publishOntologyVersionCompat(input = {}) {
-        return gateway
-            .request({
-            path: "/api/platform/v1/ontologies/versions/publish",
-            method: "POST",
-            body: input,
-            idempotencyKey: randomIdempotencyKey(),
-        })
-            .then(exposeGatewayData);
-    }
-    async function deprecateOntologyVersionCompat(input = {}) {
-        return gateway
-            .request({
-            path: "/api/platform/v1/ontologies/versions/deprecate",
-            method: "POST",
-            body: input,
-            idempotencyKey: randomIdempotencyKey(),
-        })
-            .then(exposeGatewayData);
-    }
-    async function resolveEffectiveOntologyCompat(input = {}) {
-        return gateway
-            .request({
-            path: "/api/platform/v1/ontologies/effective",
-            method: "POST",
-            body: input,
-        })
-            .then(exposeGatewayData);
-    }
-    async function traceEntityImpactCompat(input = {}) {
-        return gateway
-            .request({
-            path: "/api/platform/v1/graph/trace-entity-impact",
-            method: "POST",
-            body: input,
-        })
-            .then(exposeGatewayData);
-    }
-    const nodesNamespace = {
-        list(query) {
-            return graphClient.listNodes(query);
-        },
-        get(input) {
-            return graphClient.getNode(typeof input === "string" ? { nodeId: input } : input);
-        },
-        create(input, idempotencyKey) {
-            return graphClient.createNode(input, idempotencyKey);
-        },
-        update(input, idempotencyKey) {
-            return graphClient.updateNode(input, idempotencyKey);
-        },
-        batchCreate(input, idempotencyKey) {
-            return graphClient.batchCreateNodes(input, idempotencyKey);
-        },
-        supersede(input, idempotencyKey) {
-            return graphClient.supersedeNode(input, idempotencyKey);
-        },
-        verify(input, idempotencyKey) {
-            return graphClient.verifyNode(input, idempotencyKey);
-        },
-        hardDelete(input, idempotencyKey) {
-            return graphClient.hardDeleteNode(input, idempotencyKey);
-        },
-    };
-    return {
-        config,
-        version: LUCERN_SDK_VERSION,
-        search(query, options) {
-            return searchResources(query, options);
-        },
-        events: {
-            list(query = {}) {
-                return eventsFacade.list(query).then(exposeGatewayData);
-            },
-            replay(input) {
-                return eventsFacade.replay(input).then(exposeGatewayData);
-            },
-        },
-        beliefs: {
-            create(input) {
-                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) {
-                return beliefsFacade.get(nodeId).then(exposeGatewayData);
-            },
-            refine(nodeId, textOrInput, rationale) {
-                const payload = typeof textOrInput === "string"
-                    ? { text: textOrInput, rationale }
-                    : {
-                        text: textOrInput.text,
-                        rationale: textOrInput.rationale,
-                    };
-                return beliefsFacade.refine(nodeId, payload).then(exposeGatewayData);
-            },
-            updateConfidence(nodeId, input) {
-                return beliefsFacade.updateConfidence(nodeId, input).then(exposeGatewayData);
-            },
-            modulateConfidence(nodeId, input) {
-                return beliefsFacade.updateConfidence(nodeId, input).then(exposeGatewayData);
-            },
-            updateStatus(input, idempotencyKey) {
-                return beliefsFacade
-                    .updateStatus(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            updateRationale(input, idempotencyKey) {
-                return beliefsFacade
-                    .updateRationale(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            linkBeliefs(input, idempotencyKey) {
-                return beliefsFacade
-                    .linkBeliefs(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            unlinkEvidence(input, idempotencyKey) {
-                return beliefsFacade
-                    .unlinkEvidence(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            updateCriticality(input, idempotencyKey) {
-                return beliefsFacade
-                    .updateCriticality(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            batchUpdateCriticality(input, idempotencyKey) {
-                return beliefsFacade
-                    .batchUpdateCriticality(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            reassignTopic(input, idempotencyKey) {
-                return beliefsFacade
-                    .reassignTopic(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            fork(nodeId, input) {
-                return beliefsFacade
-                    .fork(nodeId, {
-                    text: requireText(input),
-                    forkReason: input.forkReason,
-                    rationale: input.rationale,
-                })
-                    .then(exposeGatewayData);
-            },
-            archive(nodeId, input) {
-                const payload = typeof input === "string"
-                    ? { reason: input }
-                    : input
-                        ? { reason: input.reason ?? input.rationale }
-                        : undefined;
-                return beliefsFacade.archive(nodeId, payload).then(exposeGatewayData);
-            },
-            list(args) {
-                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) {
-                return beliefsFacade.lineage(nodeId).then(exposeGatewayData);
-            },
-            confidenceHistory(nodeId) {
-                return beliefsFacade.confidenceHistory(nodeId).then(exposeGatewayData);
-            },
-            createContract(nodeId, input) {
-                return beliefsFacade
-                    .createContract(nodeId, input)
-                    .then(exposeGatewayData);
-            },
-            bisect(nodeId, input) {
-                return beliefsFacade.bisect(nodeId, input).then(exposeGatewayData);
-            },
-        },
-        webhooks: {
-            create(input) {
-                return webhooksFacade.create(input).then(exposeGatewayData);
-            },
-            list(query) {
-                return webhooksFacade.list(query).then(exposeGatewayData);
-            },
-            get(id) {
-                return webhooksFacade.get(id).then(exposeGatewayData);
-            },
-            update(id, input) {
-                return webhooksFacade.update(id, input).then(exposeGatewayData);
-            },
-            delete(id) {
-                return webhooksFacade.delete(id).then(exposeGatewayData);
-            },
-            test(id, input) {
-                return webhooksFacade.test(id, input).then(exposeGatewayData);
-            },
-            deliveries(id, query) {
-                return webhooksFacade.deliveries(id, query).then(exposeGatewayData);
-            },
-            health(id) {
-                return webhooksFacade.health(id).then(exposeGatewayData);
-            },
-        },
-        edges: {
-            create(args) {
-                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, idempotencyKey) {
-                return edgesFacade.update(input, idempotencyKey).then(exposeGatewayData);
-            },
-            remove(input, idempotencyKey) {
-                return edgesFacade.remove(input, idempotencyKey).then(exposeGatewayData);
-            },
-            removeBetween(input, idempotencyKey) {
-                return edgesFacade
-                    .removeBetween(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            batchCreate(input, idempotencyKey) {
-                return edgesFacade
-                    .batchCreate(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            delete(input, idempotencyKey) {
-                return edgesFacade.delete(input, idempotencyKey).then(exposeGatewayData);
-            },
-            list(args) {
-                return edgesFacade
-                    .list({
-                    sourceId: args.sourceId,
-                    edgeType: args.edgeType,
-                    limit: args.limit,
-                    cursor: args.cursor,
-                })
-                    .then(exposeGatewayData);
-            },
-            traverse(args) {
-                return edgesFacade
-                    .traverse({
-                    startNode: args.startNode,
-                    direction: args.direction,
-                    maxDepth: args.maxDepth,
-                    topicId: args.topicId,
-                })
-                    .then(exposeGatewayData);
-            },
-        },
-        evidence: {
-            create(args) {
-                return createEvidenceCompat(args).then(exposeGatewayData);
-            },
-            add: addEvidence,
-            get(evidenceId) {
-                return evidenceFacade.get(evidenceId).then(exposeGatewayData);
-            },
-            list(args) {
-                return evidenceFacade
-                    .list({
-                    topicId: args.topicId,
-                    targetId: args.targetId,
-                    limit: args.limit,
-                    cursor: args.cursor,
-                })
-                    .then(exposeGatewayData);
-            },
-            search(args) {
-                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) {
-                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,
-                    weight: args.weight,
-                    rationale: args.rationale,
-                })
-                    .then(exposeGatewayData);
-            },
-            linkToBelief(args) {
-                return evidenceFacade
-                    .link({
-                    evidenceId: args.evidenceId,
-                    targetId: args.beliefId,
-                    weight: args.weight,
-                    rationale: args.rationale,
-                })
-                    .then((response) => ({
-                    ...response.data,
-                    beliefId: args.beliefId,
-                }));
-            },
-            updateStatus(input, idempotencyKey) {
-                return evidenceFacade
-                    .updateStatus(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            update(input, idempotencyKey) {
-                return evidenceFacade.update(input, idempotencyKey).then(exposeGatewayData);
-            },
-            flagIncorrect(input, idempotencyKey) {
-                return evidenceFacade
-                    .flagIncorrect(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            remove(input, idempotencyKey) {
-                return evidenceFacade.remove(input, idempotencyKey).then(exposeGatewayData);
-            },
-            updateVerificationStatus(input, idempotencyKey) {
-                return evidenceFacade
-                    .updateVerificationStatus(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-        },
-        questions: {
-            create(args) {
-                return questionsFacade
-                    .create({
-                    topicId: requireTopicId(args),
-                    text: args.text,
-                    priority: args.priority,
-                    linkedBeliefId: args.linkedBeliefId,
-                    metadata: args.metadata,
-                })
-                    .then(exposeGatewayData);
-            },
-            get(questionId) {
-                return questionsFacade.get(questionId).then(exposeGatewayData);
-            },
-            refine(questionId, text, refinementReason) {
-                return questionsFacade
-                    .refine(questionId, {
-                    text,
-                    rationale: refinementReason,
-                })
-                    .then(exposeGatewayData);
-            },
-            list(args) {
-                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, status, rationale) {
-                return questionsFacade
-                    .updateStatus(questionId, {
-                    status,
-                    rationale,
-                })
-                    .then(exposeGatewayData);
-            },
-            batchCreate(input, idempotencyKey) {
-                return questionsFacade
-                    .batchCreate(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            add(input, idempotencyKey) {
-                return questionsFacade.add(input, idempotencyKey).then(exposeGatewayData);
-            },
-            updatePriority(input, idempotencyKey) {
-                return questionsFacade
-                    .updatePriority(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            advanceToConviction(input, idempotencyKey) {
-                return questionsFacade
-                    .advanceToConviction(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            updateConviction(input, idempotencyKey) {
-                return questionsFacade
-                    .updateConviction(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            finalizeConviction(input, idempotencyKey) {
-                return questionsFacade
-                    .finalizeConviction(input, idempotencyKey)
-                    .then(exposeGatewayData);
-            },
-            update(input, idempotencyKey) {
-                return questionsFacade.update(input, idempotencyKey).then(exposeGatewayData);
-            },
-            delete(input, idempotencyKey) {
-                return questionsFacade.delete(input, idempotencyKey).then(exposeGatewayData);
-            },
-            answer(questionId, input) {
-                return questionsFacade
-                    .answer(questionId, input)
-                    .then(exposeGatewayData);
-            },
-            archive(questionId, reason) {
-                return questionsFacade
-                    .archive(questionId, { reason })
-                    .then(exposeGatewayData);
-            },
-            linkEvidence(args) {
-                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) {
-                return this.list({
-                    topicId: requireTopicId(args),
-                    status: args.includeAnswered ? undefined : "open",
-                }).then((data) => {
-                    const questions = (Array.isArray(data.questions) ? data.questions : []);
-                    const rank = (priority) => {
-                        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) {
-                return graphFacade
-                    .gaps({
-                    topicId: requireTopicId(args),
-                    minConfidence: args.minConfidence,
-                })
-                    .then(exposeGatewayData);
-            },
-        },
-        graph: {
-            nodes: nodesNamespace,
-            createEdge(input) {
-                return graphClient.createEdge(input);
-            },
-            neighborhood(args) {
-                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) {
-                return graphFacade
-                    .traverse({
-                    startNode: args.startNode,
-                    direction: args.direction,
-                    maxDepth: args.maxDepth ?? 3,
-                    topicId: args.topicId,
-                })
-                    .then(exposeGatewayData);
-            },
-            analyze(args) {
-                return graphFacade
-                    .analyze({
-                    topicId: requireTopicId(args),
-                    limit: args.limit,
-                    metric: args.metric,
-                })
-                    .then(exposeGatewayData);
-            },
-            bias(args) {
-                return graphFacade
-                    .bias({
-                    topicId: requireTopicId(args),
-                    threshold: args.threshold,
-                    limit: args.limit,
-                })
-                    .then(exposeGatewayData);
-            },
-            gaps(args) {
-                return graphFacade
-                    .gaps({
-                    topicId: requireTopicId(args),
-                    minConfidence: args.minConfidence,
-                })
-                    .then(exposeGatewayData);
-            },
-            falsify(args) {
-                return graphFacade
-                    .falsify({
-                    topicId: args.topicId,
-                    beliefId: args.beliefId,
-                    beliefIds: args.beliefIds,
-                    minConfidence: args.minConfidence,
-                })
-                    .then(exposeGatewayData);
-            },
-            traceEntityImpact(args) {
-                return traceEntityImpactCompat({
-                    nodeId: args.nodeId,
-                    topicId: args.topicId,
-                });
-            },
-            searchBeliefs,
-            findContradictions,
-            bisectConfidence,
-            listBeliefs,
-            detectConfirmationBias(topicId, threshold) {
-                return this.bias({
-                    topicId,
-                    threshold,
-                    limit: 200,
-                }).then((response) => ({
-                    ...response,
-                    topicId,
-                    threshold: threshold ?? 0.7,
-                }));
-            },
-            getStructureAnalysis(topicId) {
-                return this.analyze({
-                    topicId,
-                    limit: 200,
-                }).then((response) => ({
-                    ...response,
-                    topicId,
-                }));
-            },
-            getFalsificationQuestions(topicId, beliefIds) {
-                return graphFacade
-                    .falsify({
-                    topicId,
-                    beliefIds,
-                })
-                    .then(exposeGatewayData)
-                    .then((response) => ({
-                    topicId,
-                    questions: response.questions,
-                }));
-            },
-        },
-        judgments: {
-            create(input) {
-                return decisionsClient.createJudgment(input);
-            },
-            record(input) {
-                return decisionsClient.recordJudgment(input);
-            },
-            list(query) {
-                return decisionsClient.listJudgments(query);
-            },
-            get(judgmentId) {
-                return decisionsClient.getJudgment(judgmentId);
-            },
-            recordOutcome(judgmentId, input) {
-                return decisionsClient.recordJudgmentOutcome(judgmentId, input);
-            },
-            updateOutcome(judgmentId, input) {
-                return decisionsClient.updateJudgmentOutcome(judgmentId, input);
-            },
-            readiness(topicId) {
-                return decisionsClient.getJudgmentReadiness({
-                    topicId,
-                });
-            },
-            calibration(topicId) {
-                return decisionsClient.getJudgmentCalibration({
-                    topicId,
-                });
-            },
-            pendingOutcomeReview(topicId) {
-                return decisionsClient.listPendingJudgmentOutcomeReview({
-                    topicId,
-                });
-            },
-            transitionAuditIntegrity(args) {
-                return decisionsClient.getJudgmentTransitionAuditIntegrity({
-                    ...args,
-                    topicId: requireTopicId(args),
-                });
-            },
-        },
-        worktrees: {
-            createBranch(input) {
-                return workflowClient.createBranch(input);
-            },
-            createLens(input) {
-                return workflowClient.createLens(input);
-            },
-            listLenses(query) {
-                return workflowClient.listLenses(query);
-            },
-            applyLensToTopic(input) {
-                return workflowClient.applyLensToTopic(input);
-            },
-            removeLensFromTopic(input) {
-                return workflowClient.removeLensFromTopic(input);
-            },
-            create(input) {
-                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) {
-                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) {
-                return worktreesFacade.list({
-                    topicId: requireTopicId(query),
-                    status: query.status,
-                    limit: query.limit,
-                });
-            },
-            activate(worktreeId) {
-                return worktreesFacade.activate({ id: worktreeId });
-            },
-            updateMetadata(input) {
-                const dependsOn = Array.isArray(input.dependsOn)
-                    ? input.dependsOn.filter((value) => typeof value === "string")
-                    : undefined;
-                const blocks = Array.isArray(input.blocks)
-                    ? input.blocks.filter((value) => 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) {
-                return this.updateMetadata(input);
-            },
-            updateTargets(input) {
-                return worktreesFacade.updateTargets({
-                    id: input.worktreeId,
-                    addBeliefIds: input.addBeliefIds,
-                    addQuestionIds: input.addQuestionIds,
-                    removeBeliefIds: input.removeBeliefIds,
-                    removeQuestionIds: input.removeQuestionIds,
-                });
-            },
-            listAll(query = {}) {
-                return workflowClient.listAllWorktrees(query);
-            },
-            merge(worktreeId, input) {
-                return worktreesFacade.merge({
-                    id: worktreeId,
-                    outcomes: input.outcomes,
-                    summary: input.summary,
-                });
-            },
-            push(worktreeId, input) {
-                return workflowClient.push(worktreeId, input);
-            },
-            openPullRequest(worktreeId, input) {
-                return workflowClient.openPullRequest(worktreeId, input);
-            },
-            pipelineSnapshot(topicId) {
-                return mcpParityClient.pipelineSnapshot({ topicId });
-            },
-            complete(input, idempotencyKey) {
-                return worktreesFacade.complete(input, idempotencyKey);
-            },
-            advancePhase(worktreeId, idempotencyKey) {
-                return worktreesFacade.advancePhase({ worktreeId }, idempotencyKey);
-            },
-            setPhase(worktreeId, phase, idempotencyKey) {
-                return worktreesFacade.setPhase({ worktreeId, phase }, idempotencyKey);
-            },
-            patchState(input, idempotencyKey) {
-                return worktreesFacade.patchState(input, idempotencyKey);
-            },
-            bulkCreate(input, idempotencyKey) {
-                return worktreesFacade.bulkCreate(input, idempotencyKey);
-            },
-        },
-        context: {
-            listTopics(query = {}) {
-                return topicsFacade.list({
-                    ontologyId: query.ontologyId,
-                    parentTopicId: query.parentTopicId,
-                    status: query.status,
-                    type: query.type,
-                });
-            },
-            compile(topicId, input = {}) {
-                return contextClient.compile(topicId, input);
-            },
-            recordScopeLearning(input) {
-                return mcpParityClient.recordScopeLearning(input);
-            },
-            discover(input) {
-                return discoverTopics(input);
-            },
-            analyzeTopicDensity(input) {
-                return mcpParityClient.analyzeTopicDensity(input);
-            },
-            applyAutoBranching(input) {
-                return mcpParityClient.applyAutoBranching(input);
-            },
-            seedBeliefLattice(input = {}) {
-                return mcpParityClient.seedBeliefLattice(input);
-            },
-            getLatticeCoverage(input = {}) {
-                return mcpParityClient.getLatticeCoverage(input);
-            },
-            matchEntityType(input) {
-                return ontologiesFacade
-                    .match(input)
-                    .then(exposeGatewayData);
-            },
-            discoverEntityConnections(input) {
-                return discoverEntityConnections(input);
-            },
-            triggerBeliefReview(input) {
-                return triggerBeliefReview(input);
-            },
-        },
-        tasks: {
-            create(input) {
-                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, input) {
-                return tasksFacade.complete({
-                    id: taskId,
-                    outputSummary: input.outputSummary,
-                });
-            },
-            update(taskId, input) {
-                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) {
-                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 = {}) {
-                return topicsFacade.list({
-                    ontologyId: input.ontologyId,
-                    parentTopicId: input.parentTopicId,
-                    status: input.status,
-                    type: input.type,
-                });
-            },
-            get(topicId) {
-                return topicsFacade.get(topicId);
-            },
-            create(input) {
-                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, input) {
-                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, query = {}) {
-                return topicsFacade.tree({
-                    id: topicId,
-                    maxDepth: query.maxDepth,
-                });
-            },
-            getTree(input) {
-                return topicsFacade.tree({
-                    id: input.rootId,
-                    maxDepth: input.maxDepth,
-                });
-            },
-            coverage(topicId, query = {}) {
-                return topicsFacade.coverage({
-                    id: topicId,
-                    includeDescendants: query.includeDescendants,
-                    maxDepth: query.maxDepth,
-                });
-            },
-            remove(topicId, idempotencyKey) {
-                return topicsFacade.remove(topicId, idempotencyKey);
-            },
-            bulkCreate(input, idempotencyKey) {
-                return topicsFacade.bulkCreate(input, idempotencyKey);
-            },
-        },
-        answers: {
-            create(input) {
-                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) => typeof value === "string")
-                        : undefined,
-                });
-            },
-            get(input) {
-                const questionId = typeof input.questionNodeId === "string" ? input.questionNodeId : "";
-                if (!questionId) {
-                    throw new Error("questionNodeId is required");
-                }
-                return answersClient.get(questionId);
-            },
-        },
-        contradictions: {
-            flag(args) {
-                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) {
-                return contradictionsFacade
-                    .list({
-                    topicId: requireTopicId(args),
-                    status: args.status,
-                    limit: args.limit,
-                    cursor: args.cursor,
-                })
-                    .then(exposeGatewayData);
-            },
-            get(contradictionId) {
-                return contradictionsFacade.get(contradictionId).then(exposeGatewayData);
-            },
-            find: findContradictions,
-        },
-        ontologies: {
-            list(input = {}) {
-                return ontologiesFacade.list(input).then(exposeGatewayData);
-            },
-            get(ontologyId) {
-                return ontologiesFacade
-                    .get(ontologyId)
-                    .then((response) => exposeGatewayData(response));
-            },
-            bind(input, idempotencyKey) {
-                return ontologiesFacade
-                    .bind(input, idempotencyKey)
-                    .then((response) => exposeGatewayData(response));
-            },
-            match(input, idempotencyKey) {
-                return ontologiesFacade.match(input, idempotencyKey).then(exposeGatewayData);
-            },
-            create(input) {
-                return createOntologyCompat(input);
-            },
-            update(input) {
-                return updateOntologyCompat(input);
-            },
-            archive(input) {
-                return archiveOntologyCompat(input);
-            },
-            createVersion(input) {
-                return createOntologyVersionCompat(input);
-            },
-            publishVersion(input) {
-                return publishOntologyVersionCompat(input);
-            },
-            deprecateVersion(input) {
-                return deprecateOntologyVersionCompat(input);
-            },
-            resolveEffective(input) {
-                return resolveEffectiveOntologyCompat(input);
-            },
-            raw: ontologyClient,
-        },
-        coordination: {
-            registerSession(input = {}) {
-                return mcpParityClient.registerSession(input);
-            },
-            heartbeatSession(input = {}) {
-                return mcpParityClient.heartbeatSession(input);
-            },
-            endSession(input = {}) {
-                return mcpParityClient.endSession(input);
-            },
-            listActiveSessions(input = {}) {
-                return mcpParityClient.listActiveSessions(input);
-            },
-            sendAgentMessage(input) {
-                return mcpParityClient.sendAgentMessage(input);
-            },
-            broadcastMessage(input) {
-                return mcpParityClient.broadcastMessage(input);
-            },
-            getInbox(input = {}) {
-                return mcpParityClient.getAgentInbox(input);
-            },
-            claimFiles(input) {
-                return mcpParityClient.claimFiles(input);
-            },
-        },
-        policy: {
-            checkPermission(input) {
-                return policyClient.checkPermission({
-                    topicId: typeof input.topicId === "string" ? input.topicId : undefined,
-                    permission: typeof input.permission === "string"
-                        ? input.permission
-                        : 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 = {}) {
-                return policyClient.listAccessibleTopics({
-                    permission: typeof input.permission === "string"
-                        ? input.permission
-                        : 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) {
-                return policyClient.filterByPermission({
-                    topicIds: Array.isArray(input.topicIds)
-                        ? input.topicIds.filter((value) => typeof value === "string")
-                        : undefined,
-                    permission: typeof input.permission === "string"
-                        ? input.permission
-                        : undefined,
-                    principal: typeof input.principal === "string" ? input.principal : undefined,
-                    principalId: typeof input.principalId === "string" ? input.principalId : undefined,
-                });
-            },
-            manageWritePolicy(input) {
-                return mcpParityClient.manageWritePolicy(input);
-            },
-            raw: policyClient,
-        },
-        observations: {
-            ingest(input) {
-                return mcpParityClient.ingestObservation(input);
-            },
-            getContext(input) {
-                return mcpParityClient.getObservationContext(input);
-            },
-        },
-        coding: {
-            getCodeContext(input) {
-                return mcpParityClient.getCodeContext(input);
-            },
-            getChangeHistory(input) {
-                return mcpParityClient.getChangeHistory(input);
-            },
-            recordAttempt(input) {
-                return mcpParityClient.recordAttempt(input);
-            },
-            getFailureLog(input) {
-                return mcpParityClient.getFailureLog(input);
-            },
-        },
-        contracts: {
-            create(input) {
-                return createContractCompat(input);
-            },
-            list(input = {}) {
-                return listContractsCompat(input);
-            },
-            evaluate(input) {
-                return evaluateContractCompat(input);
-            },
-            getStatus(input) {
-                return getContractStatusCompat(input);
-            },
-        },
-        bootstrap: {
-            generateSessionHandoff(input) {
-                return mcpParityClient.generateSessionHandoff(input);
-            },
-        },
-        research: {
-            searchSources(args) {
-                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) {
-                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) {
-                return registerCustomTool(registration);
-            },
-            unregister(fullName) {
-                return unregisterCustomTool(fullName);
-            },
-            list() {
-                return listRegisteredCustomTools();
-            },
-            clear() {
-                clearRegisteredCustomTools();
-            },
-            invoke(name, input = {}) {
-                const fullName = name.includes(".") ? name : `custom.${name}`;
-                return invokeCustomTool(fullName, input);
-            },
-            namespace(namespace) {
-                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) {
-                return packsClient.listStates(scope);
-            },
-            states(scope) {
-                return packsClient.getStates(scope);
-            },
-            install(input) {
-                return packsClient.install(input);
-            },
-            enable(input) {
-                return packsClient.enable(input);
-            },
-            disable(input) {
-                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,
-        },
-    };
-}