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

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

@@ -1,131 +0,0 @@
-import { createGatewayRequestClient, LucernApiError, randomIdempotencyKey, toQueryString, } from "./coreClient.js";
-import { createListResult, mapGatewayData } from "./sdkSurface.js";
-function createIdentityWhoamiClient(config = {}) {
-    const gateway = createGatewayRequestClient(config);
-    return {
-        async whoami() {
-            return gateway.request({
-                path: "/api/platform/v1/identity/whoami",
-            });
-        },
-    };
-}
-export { LucernApiError };
-/**
- * Create the identity client for principals and API keys.
- * @param config - Gateway transport configuration.
- * @returns An object with methods for whoami, principal management, and key management.
- */
-export function createIdentityClient(config = {}) {
-    const gateway = createGatewayRequestClient(config);
-    const whoamiClient = createIdentityWhoamiClient(config);
-    const requestPrincipalWrite = (method, input, idempotencyKey) => gateway.request({
-        path: "/api/platform/v1/identity/principals",
-        method,
-        body: input,
-        idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
-    });
-    return {
-        /**
-         * Resolve the current authenticated identity summary.
-         */
-        async whoami() {
-            return whoamiClient.whoami().then((response) => mapGatewayData(response, (data) => ({
-                principalId: data.principalId,
-                principalType: data.principalType,
-                tenantId: data.tenantId ?? null,
-                workspaceId: data.workspaceId ?? null,
-                scopes: Array.isArray(data.scopes) ? data.scopes : [],
-                roles: Array.isArray(data.roles) ? data.roles : [],
-                isPlatformAdmin: data.isPlatformAdmin === true,
-                isTenantAdmin: data.isTenantAdmin === true,
-                isWorkspaceAdmin: data.isWorkspaceAdmin === true,
-                authMode: data.authMode,
-                sessionId: data.sessionId,
-                delegatedBy: data.delegatedBy,
-                expiresAt: data.expiresAt,
-            })));
-        },
-        /**
-         * List principals in the current identity scope.
-         */
-        async listPrincipals(query = {}) {
-            return gateway.request({
-                path: `/api/platform/v1/identity/principals${toQueryString(query)}`,
-            }).then((response) => mapGatewayData(response, (data) => createListResult(Array.isArray(data) ? data : [], "principals")));
-        },
-        /**
-         * Create a principal.
-         */
-        async createPrincipal(input, idempotencyKey) {
-            return requestPrincipalWrite("POST", input, idempotencyKey);
-        },
-        /**
-         * Update a principal.
-         */
-        async updatePrincipal(input, idempotencyKey) {
-            return requestPrincipalWrite("PATCH", input, idempotencyKey);
-        },
-        /**
-         * @deprecated Use createPrincipal or updatePrincipal.
-         */
-        async upsertPrincipal(input, idempotencyKey) {
-            return requestPrincipalWrite("PATCH", input, idempotencyKey);
-        },
-        /**
-         * List keys in the current identity scope.
-         */
-        async listKeys(query = {}) {
-            return gateway.request({
-                path: `/api/platform/v1/identity/keys${toQueryString(query)}`,
-            }).then((response) => mapGatewayData(response, (data) => createListResult(Array.isArray(data) ? data : [], "keys")));
-        },
-        /**
-         * Create an API key.
-         */
-        async createKey(input, idempotencyKey) {
-            return gateway.request({
-                path: "/api/platform/v1/identity/keys",
-                method: "POST",
-                body: input,
-                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
-            });
-        },
-        /**
-         * Rotate an API key.
-         */
-        async rotateKey(keyId, input = {}, idempotencyKey) {
-            return gateway.request({
-                path: `/api/platform/v1/identity/keys/${encodeURIComponent(keyId)}/rotate`,
-                method: "POST",
-                body: input,
-                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
-            });
-        },
-        /**
-         * Delete an API key by revoking it.
-         */
-        async deleteKey(keyId, input = {}, idempotencyKey) {
-            return gateway.request({
-                path: `/api/platform/v1/identity/keys/${encodeURIComponent(keyId)}/revoke`,
-                method: "POST",
-                body: input,
-                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
-            });
-        },
-        /**
-         * @deprecated Use deleteKey.
-         */
-        async revokeKey(keyId, input = {}, idempotencyKey) {
-            return this.deleteKey(keyId, input, idempotencyKey);
-        },
-        /**
-         * Search Clerk users by email or display attributes.
-         */
-        async searchClerkUsers(q) {
-            return gateway.request({
-                path: `/api/platform/v1/identity/clerk-users${toQueryString({ q })}`,
-            });
-        },
-    };
-}

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

@@ -1,49 +0,0 @@
-/**
- * @lucern/sdk — The reasoning operating system for AI-native applications.
- *
- * This is the main entry point. It re-exports all client factories,
- * types, contracts, and utilities from domain modules.
- *
- * @packageDocumentation
- */
-export * from "./adminClient.js";
-export * from "./answersClient.js";
-export * from "./audiencesClient.js";
-export * from "./auditClient.js";
-export * from "./beliefsClient.js";
-export * from "./client.js";
-export * from "./contextFacade.js";
-export * from "./contextPackCompiler.js";
-export * from "./controlObjectOwnership.js";
-export * from "./coreClient.js";
-export * from "./contextClient.js";
-export * from "./contracts/api-enums.contract.js";
-export * from "./contracts/auth-session.contract.js";
-export { MAX_ENTITY_LIMIT } from "./contracts/contextPack.js";
-export * from "./contracts/lensFilter.js";
-export * from "./contracts/lensWorkflow.js";
-export * from "./contracts/mcpTools.js";
-export * from "./contracts/prompt.js";
-export * from "./contracts/workflowRuntime.js";
-export * from "./domainContext.js";
-export * from "./customTools.js";
-export * from "./decisionsClient.js";
-export * from "./events.js";
-export * from "./eventsCore.js";
-export * from "./graphClient.js";
-export * from "./harnessClient.js";
-export * from "./identityClient.js";
-export * from "./learningClient.js";
-export * from "./mcpParityClient.js";
-export * from "./mcpParitySurface.js";
-export * from "./ontologyClient.js";
-export * from "./packRuntime.js";
-export * from "./packsClient.js";
-export * from "./policyClient.js";
-export * from "./reportsClient.js";
-export * from "./schemaClient.js";
-export * from "./sdkSurface.js";
-export * from "./topicsClient.js";
-export * from "./types.js";
-export * from "./version.js";
-export * from "./workflowClient.js";

package/dist/lib/platform/sdk/learningClient.d.ts

@@ -1,40 +0,0 @@
-import { type GatewayClientConfig } from "./coreClient";
-import type { TopicIdentifierInput } from "./types";
-/** Configuration for the learning client. */
-export type LearningClientConfig = GatewayClientConfig;
-/**
- * Create the learning client for execution telemetry reads.
- * @param config - Gateway transport configuration.
- * @returns An object with methods to list executions and retrieve stats.
- */
-export declare function createLearningClient(config?: LearningClientConfig): {
-    /**
-     * List recent execution records.
-     */
-    listRecentExecutions(args?: {
-        namespace?: string;
-        topicId?: string;
-        audienceMode?: string;
-        success?: boolean;
-        limit?: number;
-    } & TopicIdentifierInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "executions">>>;
-    /**
-     * @deprecated Use listRecentExecutions.
-     */
-    getRecentExecutions(args?: {
-        namespace?: string;
-        topicId?: string;
-        audienceMode?: string;
-        success?: boolean;
-        limit?: number;
-    } & TopicIdentifierInput): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").ListResult<any, "executions">>>;
-    /**
-     * Get aggregate execution statistics.
-     */
-    getExecutionStats(args?: {
-        namespace?: string;
-        topicId?: string;
-        audienceMode?: string;
-        hours?: number;
-    } & TopicIdentifierInput): Promise<import("./coreClient").PlatformGatewaySuccess<unknown>>;
-};

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

@@ -1,53 +0,0 @@
-import { createGatewayRequestClient, toQueryString, } from "./coreClient.js";
-import { createListResult, mapGatewayData, normalizeTopicQuery } from "./sdkSurface.js";
-/**
- * Create the learning client for execution telemetry reads.
- * @param config - Gateway transport configuration.
- * @returns An object with methods to list executions and retrieve stats.
- */
-export function createLearningClient(config = {}) {
-    const gateway = createGatewayRequestClient(config);
-    return {
-        /**
-         * List recent execution records.
-         */
-        async listRecentExecutions(args = {}) {
-            return gateway.request({
-                path: `/api/platform/v1/learning/executions/recent${toQueryString({
-                    ...normalizeTopicQuery(args),
-                    namespace: args.namespace,
-                    audienceMode: args.audienceMode,
-                    success: typeof args.success === "boolean"
-                        ? args.success
-                            ? "true"
-                            : "false"
-                        : undefined,
-                    limit: typeof args.limit === "number" && Number.isFinite(args.limit)
-                        ? String(args.limit)
-                        : undefined,
-                })}`,
-            }).then((response) => mapGatewayData(response, (data) => createListResult(Array.isArray(data) ? data : [], "executions")));
-        },
-        /**
-         * @deprecated Use listRecentExecutions.
-         */
-        async getRecentExecutions(args = {}) {
-            return this.listRecentExecutions(args);
-        },
-        /**
-         * Get aggregate execution statistics.
-         */
-        async getExecutionStats(args = {}) {
-            return gateway.request({
-                path: `/api/platform/v1/learning/executions/stats${toQueryString({
-                    ...normalizeTopicQuery(args),
-                    namespace: args.namespace,
-                    audienceMode: args.audienceMode,
-                    hours: typeof args.hours === "number" && Number.isFinite(args.hours)
-                        ? String(args.hours)
-                        : undefined,
-                })}`,
-            });
-        },
-    };
-}

package/dist/lib/platform/sdk/mcpParityClient.d.ts

@@ -1,69 +0,0 @@
-import { type GatewayClientConfig, type PlatformGatewaySuccess } from "./coreClient";
-import type { JsonObject } from "./types";
-/** Configuration for the MCP parity client. Inherits gateway transport settings. */
-export type McpParityClientConfig = GatewayClientConfig;
-type ToolArgs = JsonObject;
-type ToolResult<T = unknown> = Promise<PlatformGatewaySuccess<T>>;
-/**
- * Thin typed bridge for MCP-only SDK parity methods.
- *
- * These methods map 1:1 to the Lucern MCP handlers and execute through the
- * platform gateway so the SDK can cover the full control-plane surface.
- */
-export declare function createMcpParityClient(config?: McpParityClientConfig): {
-    sessionId: `${string}-${string}-${string}-${string}-${string}`;
-    listTopics(args?: ToolArgs): ToolResult<unknown>;
-    createTopic(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    getTopic(args: ToolArgs): ToolResult<unknown>;
-    getTopicTree(args: ToolArgs): ToolResult<unknown>;
-    activateWorktree(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    updateWorktreeMetadata(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    updateWorktreeTargets(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    listAllWorktrees(args?: ToolArgs): ToolResult<unknown>;
-    pipelineSnapshot(args: ToolArgs): ToolResult<unknown>;
-    recordScopeLearning(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    discover(args: ToolArgs): ToolResult<unknown>;
-    analyzeTopicDensity(args: ToolArgs): ToolResult<unknown>;
-    applyAutoBranching(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    seedBeliefLattice(args?: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    getLatticeCoverage(args?: ToolArgs): ToolResult<unknown>;
-    matchEntityType(args: ToolArgs): ToolResult<unknown>;
-    discoverEntityConnections(args: ToolArgs): ToolResult<unknown>;
-    triggerBeliefReview(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    listOntologies(args?: ToolArgs): ToolResult<unknown>;
-    getOntology(args: ToolArgs): ToolResult<unknown>;
-    applyOntology(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    createOntology(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    updateOntology(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    archiveOntology(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    createOntologyVersion(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    publishOntologyVersion(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    deprecateOntologyVersion(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    resolveEffectiveOntology(args: ToolArgs): ToolResult<unknown>;
-    registerSession(args?: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    heartbeatSession(args?: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    endSession(args?: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    listActiveSessions(args?: ToolArgs): ToolResult<unknown>;
-    sendAgentMessage(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    broadcastMessage(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    getAgentInbox(args?: ToolArgs): ToolResult<unknown>;
-    claimFiles(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    listTasks(args: ToolArgs): ToolResult<unknown>;
-    createAnswer(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    getAnswer(args: ToolArgs): ToolResult<unknown>;
-    flagContradiction(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    ingestObservation(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    getObservationContext(args: ToolArgs): ToolResult<unknown>;
-    getCodeContext(args: ToolArgs): ToolResult<unknown>;
-    getChangeHistory(args: ToolArgs): ToolResult<unknown>;
-    recordAttempt(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    getFailureLog(args: ToolArgs): ToolResult<unknown>;
-    createEpistemicContract(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    evaluateContract(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    getContractStatus(args: ToolArgs): ToolResult<unknown>;
-    checkPermission(args: ToolArgs): ToolResult<unknown>;
-    filterByPermission(args: ToolArgs): ToolResult<unknown>;
-    manageWritePolicy(args: ToolArgs, idempotencyKey?: string): ToolResult<unknown>;
-    generateSessionHandoff(args: ToolArgs): ToolResult<unknown>;
-};
-export {};

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

@@ -1,196 +0,0 @@
-import { createGatewayRequestClient, randomIdempotencyKey, } from "./coreClient.js";
-function withSdkSessionId(args, sessionId) {
-    return {
-        ...(args ?? {}),
-        __sdkSessionId: sessionId,
-    };
-}
-/**
- * Thin typed bridge for MCP-only SDK parity methods.
- *
- * These methods map 1:1 to the Lucern MCP handlers and execute through the
- * platform gateway so the SDK can cover the full control-plane surface.
- */
-export function createMcpParityClient(config = {}) {
-    const gateway = createGatewayRequestClient(config);
-    const sessionId = crypto.randomUUID();
-    function executeRead(toolName, args) {
-        return gateway.request({
-            path: `/api/platform/v1/mcp-tools/${encodeURIComponent(toolName)}`,
-            method: "POST",
-            body: withSdkSessionId(args, sessionId),
-        });
-    }
-    function executeMutation(toolName, args, idempotencyKey) {
-        return gateway.request({
-            path: `/api/platform/v1/mcp-tools/${encodeURIComponent(toolName)}`,
-            method: "POST",
-            body: withSdkSessionId(args, sessionId),
-            idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
-        });
-    }
-    return {
-        sessionId,
-        listTopics(args = {}) {
-            return executeRead("list_topics", args);
-        },
-        createTopic(args, idempotencyKey) {
-            return executeMutation("create_topic", args, idempotencyKey);
-        },
-        getTopic(args) {
-            return executeRead("get_topic", args);
-        },
-        getTopicTree(args) {
-            return executeRead("get_topic_tree", args);
-        },
-        activateWorktree(args, idempotencyKey) {
-            return executeMutation("activate_worktree", args, idempotencyKey);
-        },
-        updateWorktreeMetadata(args, idempotencyKey) {
-            return executeMutation("update_worktree_metadata", args, idempotencyKey);
-        },
-        updateWorktreeTargets(args, idempotencyKey) {
-            return executeMutation("update_worktree_targets", args, idempotencyKey);
-        },
-        listAllWorktrees(args = {}) {
-            return executeRead("list_all_worktrees", args);
-        },
-        pipelineSnapshot(args) {
-            return executeRead("pipeline_snapshot", args);
-        },
-        recordScopeLearning(args, idempotencyKey) {
-            return executeMutation("record_scope_learning", args, idempotencyKey);
-        },
-        discover(args) {
-            return executeRead("discover", args);
-        },
-        analyzeTopicDensity(args) {
-            return executeRead("analyze_topic_density", args);
-        },
-        applyAutoBranching(args, idempotencyKey) {
-            return executeMutation("apply_auto_branching", args, idempotencyKey);
-        },
-        seedBeliefLattice(args = {}, idempotencyKey) {
-            return executeMutation("seed_belief_lattice", args, idempotencyKey);
-        },
-        getLatticeCoverage(args = {}) {
-            return executeRead("get_lattice_coverage", args);
-        },
-        matchEntityType(args) {
-            return executeRead("match_entity_type", args);
-        },
-        discoverEntityConnections(args) {
-            return executeRead("discover_entity_connections", args);
-        },
-        triggerBeliefReview(args, idempotencyKey) {
-            return executeMutation("trigger_belief_review", args, idempotencyKey);
-        },
-        listOntologies(args = {}) {
-            return executeRead("list_ontologies", args);
-        },
-        getOntology(args) {
-            return executeRead("get_ontology", args);
-        },
-        applyOntology(args, idempotencyKey) {
-            return executeMutation("apply_ontology", args, idempotencyKey);
-        },
-        createOntology(args, idempotencyKey) {
-            return executeMutation("create_ontology", args, idempotencyKey);
-        },
-        updateOntology(args, idempotencyKey) {
-            return executeMutation("update_ontology", args, idempotencyKey);
-        },
-        archiveOntology(args, idempotencyKey) {
-            return executeMutation("archive_ontology", args, idempotencyKey);
-        },
-        createOntologyVersion(args, idempotencyKey) {
-            return executeMutation("create_ontology_version", args, idempotencyKey);
-        },
-        publishOntologyVersion(args, idempotencyKey) {
-            return executeMutation("publish_ontology_version", args, idempotencyKey);
-        },
-        deprecateOntologyVersion(args, idempotencyKey) {
-            return executeMutation("deprecate_ontology_version", args, idempotencyKey);
-        },
-        resolveEffectiveOntology(args) {
-            return executeRead("resolve_effective_ontology", args);
-        },
-        registerSession(args = {}, idempotencyKey) {
-            return executeMutation("register_session", args, idempotencyKey);
-        },
-        heartbeatSession(args = {}, idempotencyKey) {
-            return executeMutation("heartbeat_session", args, idempotencyKey);
-        },
-        endSession(args = {}, idempotencyKey) {
-            return executeMutation("end_session", args, idempotencyKey);
-        },
-        listActiveSessions(args = {}) {
-            return executeRead("list_active_sessions", args);
-        },
-        sendAgentMessage(args, idempotencyKey) {
-            return executeMutation("send_agent_message", args, idempotencyKey);
-        },
-        broadcastMessage(args, idempotencyKey) {
-            return executeMutation("broadcast_message", args, idempotencyKey);
-        },
-        getAgentInbox(args = {}) {
-            return executeRead("get_agent_inbox", args);
-        },
-        claimFiles(args, idempotencyKey) {
-            return executeMutation("claim_files", args, idempotencyKey);
-        },
-        listTasks(args) {
-            return executeRead("list_tasks", args);
-        },
-        createAnswer(args, idempotencyKey) {
-            return executeMutation("create_answer", args, idempotencyKey);
-        },
-        getAnswer(args) {
-            return executeRead("get_answer", args);
-        },
-        flagContradiction(args, idempotencyKey) {
-            return executeMutation("flag_contradiction", args, idempotencyKey);
-        },
-        ingestObservation(args, idempotencyKey) {
-            return executeMutation("ingest_observation", args, idempotencyKey);
-        },
-        getObservationContext(args) {
-            return executeRead("get_observation_context", args);
-        },
-        getCodeContext(args) {
-            return executeRead("get_code_context", args);
-        },
-        getChangeHistory(args) {
-            return executeRead("get_change_history", args);
-        },
-        recordAttempt(args, idempotencyKey) {
-            return executeMutation("record_attempt", args, idempotencyKey);
-        },
-        getFailureLog(args) {
-            return executeRead("get_failure_log", args);
-        },
-        createEpistemicContract(args, idempotencyKey) {
-            return executeMutation("create_epistemic_contract", args, idempotencyKey);
-        },
-        evaluateContract(args, idempotencyKey) {
-            return executeMutation("evaluate_contract", args, idempotencyKey);
-        },
-        getContractStatus(args) {
-            return executeRead("get_contract_status", args);
-        },
-        checkPermission(args) {
-            return executeRead("check_permission", args);
-        },
-        filterByPermission(args) {
-            return executeRead("filter_by_permission", args);
-        },
-        manageWritePolicy(args, idempotencyKey) {
-            return args.action === "set"
-                ? executeMutation("manage_write_policy", args, idempotencyKey)
-                : executeRead("manage_write_policy", args);
-        },
-        generateSessionHandoff(args) {
-            return executeRead("generate_session_handoff", args);
-        },
-    };
-}

package/dist/lib/platform/sdk/mcpParitySurface.d.ts

@@ -1,10 +0,0 @@
-/** Descriptor mapping an MCP tool name to its SDK method path and read/mutation classification. */
-export type McpParityMethod = {
-    toolName: string;
-    methodPath: string;
-    kind: "read" | "mutation";
-};
-/** Complete registry of MCP tools with SDK parity, mapping tool names to SDK method paths. */
-export declare const SDK_MCP_PARITY_METHODS: readonly McpParityMethod[];
-export declare const SDK_MCP_PARITY_METHOD_PATHS: string[];
-export declare const SDK_MCP_PARITY_TOOL_NAMES: string[];

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

@@ -1,57 +0,0 @@
-/** Complete registry of MCP tools with SDK parity, mapping tool names to SDK method paths. */
-export const SDK_MCP_PARITY_METHODS = [
-    { toolName: "activate_worktree", methodPath: "worktrees.activate", kind: "mutation" },
-    { toolName: "update_worktree_metadata", methodPath: "worktrees.updateMetadata", kind: "mutation" },
-    { toolName: "update_worktree_targets", methodPath: "worktrees.updateTargets", kind: "mutation" },
-    { toolName: "list_all_worktrees", methodPath: "worktrees.listAll", kind: "read" },
-    { toolName: "pipeline_snapshot", methodPath: "worktrees.pipelineSnapshot", kind: "read" },
-    { toolName: "record_scope_learning", methodPath: "context.recordScopeLearning", kind: "mutation" },
-    { toolName: "discover", methodPath: "context.discover", kind: "read" },
-    { toolName: "analyze_topic_density", methodPath: "context.analyzeTopicDensity", kind: "read" },
-    { toolName: "apply_auto_branching", methodPath: "context.applyAutoBranching", kind: "mutation" },
-    { toolName: "seed_belief_lattice", methodPath: "context.seedBeliefLattice", kind: "mutation" },
-    { toolName: "get_lattice_coverage", methodPath: "context.getLatticeCoverage", kind: "read" },
-    { toolName: "match_entity_type", methodPath: "context.matchEntityType", kind: "read" },
-    { toolName: "discover_entity_connections", methodPath: "context.discoverEntityConnections", kind: "read" },
-    { toolName: "trigger_belief_review", methodPath: "context.triggerBeliefReview", kind: "mutation" },
-    { toolName: "list_ontologies", methodPath: "ontologies.list", kind: "read" },
-    { toolName: "get_ontology", methodPath: "ontologies.get", kind: "read" },
-    { toolName: "apply_ontology", methodPath: "ontologies.bind", kind: "mutation" },
-    { toolName: "create_ontology", methodPath: "ontologies.create", kind: "mutation" },
-    { toolName: "update_ontology", methodPath: "ontologies.update", kind: "mutation" },
-    { toolName: "archive_ontology", methodPath: "ontologies.archive", kind: "mutation" },
-    { toolName: "create_ontology_version", methodPath: "ontologies.createVersion", kind: "mutation" },
-    { toolName: "publish_ontology_version", methodPath: "ontologies.publishVersion", kind: "mutation" },
-    { toolName: "deprecate_ontology_version", methodPath: "ontologies.deprecateVersion", kind: "mutation" },
-    { toolName: "resolve_effective_ontology", methodPath: "ontologies.resolveEffective", kind: "read" },
-    { toolName: "register_session", methodPath: "coordination.registerSession", kind: "mutation" },
-    { toolName: "heartbeat_session", methodPath: "coordination.heartbeatSession", kind: "mutation" },
-    { toolName: "end_session", methodPath: "coordination.endSession", kind: "mutation" },
-    { toolName: "list_active_sessions", methodPath: "coordination.listActiveSessions", kind: "read" },
-    { toolName: "send_agent_message", methodPath: "coordination.sendAgentMessage", kind: "mutation" },
-    { toolName: "broadcast_message", methodPath: "coordination.broadcastMessage", kind: "mutation" },
-    { toolName: "get_agent_inbox", methodPath: "coordination.getInbox", kind: "read" },
-    { toolName: "claim_files", methodPath: "coordination.claimFiles", kind: "mutation" },
-    { toolName: "create_topic", methodPath: "topics.create", kind: "mutation" },
-    { toolName: "get_topic", methodPath: "topics.get", kind: "read" },
-    { toolName: "get_topic_tree", methodPath: "topics.getTree", kind: "read" },
-    { toolName: "list_tasks", methodPath: "tasks.list", kind: "read" },
-    { toolName: "create_answer", methodPath: "answers.create", kind: "mutation" },
-    { toolName: "get_answer", methodPath: "answers.get", kind: "read" },
-    { toolName: "flag_contradiction", methodPath: "contradictions.flag", kind: "mutation" },
-    { toolName: "ingest_observation", methodPath: "observations.ingest", kind: "mutation" },
-    { toolName: "get_observation_context", methodPath: "observations.getContext", kind: "read" },
-    { toolName: "get_code_context", methodPath: "coding.getCodeContext", kind: "read" },
-    { toolName: "get_change_history", methodPath: "coding.getChangeHistory", kind: "read" },
-    { toolName: "record_attempt", methodPath: "coding.recordAttempt", kind: "mutation" },
-    { toolName: "get_failure_log", methodPath: "coding.getFailureLog", kind: "read" },
-    { toolName: "create_epistemic_contract", methodPath: "contracts.create", kind: "mutation" },
-    { toolName: "evaluate_contract", methodPath: "contracts.evaluate", kind: "mutation" },
-    { toolName: "get_contract_status", methodPath: "contracts.getStatus", kind: "read" },
-    { toolName: "check_permission", methodPath: "policy.checkPermission", kind: "read" },
-    { toolName: "filter_by_permission", methodPath: "policy.filterByPermission", kind: "read" },
-    { toolName: "manage_write_policy", methodPath: "policy.manageWritePolicy", kind: "mutation" },
-    { toolName: "generate_session_handoff", methodPath: "bootstrap.generateSessionHandoff", kind: "read" },
-];
-export const SDK_MCP_PARITY_METHOD_PATHS = SDK_MCP_PARITY_METHODS.map((entry) => entry.methodPath);
-export const SDK_MCP_PARITY_TOOL_NAMES = SDK_MCP_PARITY_METHODS.map((entry) => entry.toolName);