@lucern/sdk 0.2.0-alpha.9 → 0.3.0-alpha.0

package/dist/index.js

@@ -1,4 +1,201 @@
 import { z } from 'zod';
+import * as tool_contracts_star from '@lucern/contracts/tool-contracts';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BELIEF_STATUSES: () => BELIEF_STATUSES,
+  BRANCH_DEPRECATION_MESSAGE: () => BRANCH_DEPRECATION_MESSAGE,
+  CANONICAL_WORKFLOW_DEFINITIONS: () => CANONICAL_WORKFLOW_DEFINITIONS,
+  CONFIDENCE_TRIGGERS: () => CONFIDENCE_TRIGGERS,
+  CONTRADICTION_SEVERITIES: () => CONTRADICTION_SEVERITIES,
+  CONTRADICTION_STATUSES: () => CONTRADICTION_STATUSES,
+  CONTROL_OBJECT_BLAST_RADII: () => CONTROL_OBJECT_BLAST_RADII,
+  CONTROL_OBJECT_EDIT_SURFACES: () => CONTROL_OBJECT_EDIT_SURFACES,
+  CONTROL_OBJECT_INHERITANCE_RULES: () => CONTROL_OBJECT_INHERITANCE_RULES,
+  CONTROL_OBJECT_KINDS: () => CONTROL_OBJECT_KINDS,
+  CONTROL_OBJECT_OWNERSHIP_CONTRACT: () => CONTROL_OBJECT_OWNERSHIP_CONTRACT,
+  CONTROL_OBJECT_OWNERSHIP_MATRIX: () => CONTROL_OBJECT_OWNERSHIP_MATRIX,
+  CONTROL_OBJECT_OWNERSHIP_ROWS: () => CONTROL_OBJECT_OWNERSHIP_ROWS,
+  CONTROL_OBJECT_OWNER_SCOPES: () => CONTROL_OBJECT_OWNER_SCOPES,
+  CustomToolRegistryError: () => CustomToolRegistryError,
+  DEFAULT_TIER_APPROVAL_MODE: () => DEFAULT_TIER_APPROVAL_MODE,
+  DEFAULT_WORKFLOW_AUTO_FIX_POLICY: () => DEFAULT_WORKFLOW_AUTO_FIX_POLICY,
+  DEFEAT_TYPES: () => DEFEAT_TYPES,
+  DOMAIN_EVENT_TYPES: () => DOMAIN_EVENT_TYPES,
+  DOMAIN_EVENT_VERSION: () => DOMAIN_EVENT_VERSION,
+  EDGE_TYPES: () => EDGE_TYPES,
+  EPISTEMIC_EDGE_TYPES: () => EPISTEMIC_EDGE_TYPES,
+  EPISTEMIC_LAYERS: () => EPISTEMIC_LAYERS,
+  EVENT_RETENTION_DEFAULT_DAYS: () => EVENT_RETENTION_DEFAULT_DAYS,
+  FORK_REASONS: () => FORK_REASONS,
+  FUNCTION_SURFACE_METHOD_PATHS: () => FUNCTION_SURFACE_METHOD_PATHS,
+  JUDGMENT_TYPES: () => JUDGMENT_TYPES,
+  LENS_PERSPECTIVE_TYPES: () => LENS_PERSPECTIVE_TYPES,
+  LENS_STATUSES: () => LENS_STATUSES,
+  LENS_TASK_TEMPLATE_PRIORITIES: () => LENS_TASK_TEMPLATE_PRIORITIES,
+  LUCERN_SDK_VERSION: () => LUCERN_SDK_VERSION,
+  LucernApiError: () => LucernApiError,
+  MAX_ENTITY_LIMIT: () => MAX_ENTITY_LIMIT,
+  MERGE_OUTCOMES: () => MERGE_OUTCOMES,
+  MORNING_BRIEF_WORKFLOW_ID: () => MORNING_BRIEF_WORKFLOW_ID,
+  NIGHTLY_RECONCILIATION_WORKFLOW_ID: () => NIGHTLY_RECONCILIATION_WORKFLOW_ID,
+  REASONING_METHODS: () => REASONING_METHODS,
+  SESSION_AUTH_MODES: () => SESSION_AUTH_MODES,
+  SESSION_LIFECYCLE_STATUSES: () => SESSION_LIFECYCLE_STATUSES,
+  SESSION_PRINCIPAL_TYPES: () => SESSION_PRINCIPAL_TYPES,
+  STRUCTURAL_EDGE_TYPES: () => STRUCTURAL_EDGE_TYPES,
+  WEBHOOK_MAX_ATTEMPTS: () => WEBHOOK_MAX_ATTEMPTS,
+  WEBHOOK_RETRY_DELAYS_MS: () => WEBHOOK_RETRY_DELAYS_MS,
+  WORKFLOW_ACTION_KINDS: () => WORKFLOW_ACTION_KINDS,
+  WORKFLOW_APPROVAL_MODES: () => WORKFLOW_APPROVAL_MODES,
+  WORKFLOW_AUTO_FIX_MODES: () => WORKFLOW_AUTO_FIX_MODES,
+  WORKFLOW_HOOK_EVENTS: () => WORKFLOW_HOOK_EVENTS,
+  WORKFLOW_INTEGRITY_CHECKS: () => WORKFLOW_INTEGRITY_CHECKS,
+  WORKFLOW_MUTATION_TIERS: () => WORKFLOW_MUTATION_TIERS,
+  WORKFLOW_OUTPUT_KINDS: () => WORKFLOW_OUTPUT_KINDS,
+  WORKFLOW_PROOF_ARTIFACT_KINDS: () => WORKFLOW_PROOF_ARTIFACT_KINDS,
+  WORKFLOW_RUNTIME_SCHEMA_VERSION: () => WORKFLOW_RUNTIME_SCHEMA_VERSION,
+  WORKFLOW_RUN_STATUSES: () => WORKFLOW_RUN_STATUSES,
+  WORKFLOW_STAFFING_HINTS: () => WORKFLOW_STAFFING_HINTS,
+  WORKFLOW_TRIGGER_KINDS: () => WORKFLOW_TRIGGER_KINDS,
+  WORKTREE_PHASES: () => WORKTREE_PHASES,
+  asListItems: () => asListItems,
+  assertValidWebhookSecret: () => assertValidWebhookSecret,
+  assertValidWebhookUrl: () => assertValidWebhookUrl,
+  buildDeprecatedBranchMetadata: () => buildDeprecatedBranchMetadata,
+  buildDomainEvent: () => buildDomainEvent,
+  clearRegisteredCustomTools: () => clearRegisteredCustomTools,
+  compareEventCursor: () => compareEventCursor,
+  compileContextPackFromSnapshot: () => compileContextPackFromSnapshot,
+  computeWebhookSignature: () => computeWebhookSignature,
+  createAdminClient: () => createAdminClient,
+  createAnswersClient: () => createAnswersClient,
+  createAudiencesClient: () => createAudiencesClient,
+  createAuditClient: () => createAuditClient,
+  createBeliefsClient: () => createBeliefsClient,
+  createContextClient: () => createContextClient,
+  createContextFacade: () => createContextFacade,
+  createDecisionsClient: () => createDecisionsClient,
+  createEventId: () => createEventId,
+  createEventsClientCore: () => createEventsClientCore,
+  createEvidenceClient: () => createEvidenceClient,
+  createFunctionSurfaceClient: () => createFunctionSurfaceClient,
+  createGatewayRequestClient: () => createGatewayRequestClient,
+  createGraphClient: () => createGraphClient,
+  createHarnessClient: () => createHarnessClient,
+  createIdentityClient: () => createIdentityClient,
+  createLearningClient: () => createLearningClient,
+  createListResult: () => createListResult,
+  createLucernClient: () => createLucernClient,
+  createOntologyClient: () => createOntologyClient,
+  createPacksClient: () => createPacksClient,
+  createPolicyClient: () => createPolicyClient,
+  createReportsClient: () => createReportsClient,
+  createSchemaClient: () => createSchemaClient,
+  createSourcesClient: () => createSourcesClient,
+  createTopicsClient: () => createTopicsClient,
+  createWebhooksClientCore: () => createWebhooksClientCore,
+  createWorkflowClient: () => createWorkflowClient,
+  decodeEventCursor: () => decodeEventCursor,
+  emitDomainEvent: () => emitDomainEvent,
+  encodeEventCursor: () => encodeEventCursor,
+  eventPatternToRegExp: () => eventPatternToRegExp,
+  getControlObjectOwnershipCase: () => getControlObjectOwnershipCase,
+  getRegisteredCustomTool: () => getRegisteredCustomTool,
+  inferActorType: () => inferActorType,
+  inferLensPerspectiveTypeFromBranchSchema: () => inferLensPerspectiveTypeFromBranchSchema,
+  inferSessionPrincipalType: () => inferSessionPrincipalType,
+  invokeRegisteredCustomTool: () => invokeRegisteredCustomTool,
+  isAfterCursor: () => isAfterCursor,
+  isLensFilterCriteria: () => isLensFilterCriteria,
+  isLucernPrompt: () => isLucernPrompt,
+  isTaxonomyFilterCriteriaV1: () => isTaxonomyFilterCriteriaV1,
+  lastDelegator: () => lastDelegator,
+  listControlObjectOwnershipCases: () => listControlObjectOwnershipCases,
+  listRegisteredCustomTools: () => listRegisteredCustomTools,
+  mapAliasedList: () => mapAliasedList,
+  mapGatewayData: () => mapGatewayData,
+  mapOpinionHistoryEntriesFromGatewayData: () => mapOpinionHistoryEntriesFromGatewayData,
+  matchesAnyEventPattern: () => matchesAnyEventPattern,
+  matchesEventPattern: () => matchesEventPattern,
+  migrateBranchToLens: () => migrateBranchToLens,
+  nextDeliveryAttemptAt: () => nextDeliveryAttemptAt,
+  normalizeDelegationChain: () => normalizeDelegationChain,
+  normalizeNodeVerificationStatus: () => normalizeNodeVerificationStatus,
+  normalizeNodeWriteInput: () => normalizeNodeWriteInput,
+  normalizeRetentionDays: () => normalizeRetentionDays,
+  normalizeTopicQuery: () => normalizeTopicQuery,
+  normalizeWebhookPatterns: () => normalizeWebhookPatterns,
+  opinionFromBaseRate: () => opinionFromBaseRate,
+  opinionFromDogmatic: () => opinionFromDogmatic,
+  opinionFromProjected: () => opinionFromProjected,
+  planContextPackCompilation: () => planContextPackCompilation,
+  randomIdempotencyKey: () => randomIdempotencyKey,
+  registerCustomTool: () => registerCustomTool,
+  resolveDeliveryFailureStatus: () => resolveDeliveryFailureStatus,
+  resolveText: () => resolveText,
+  resolveTopicId: () => resolveTopicId,
+  sanitizeWebhookRecord: () => sanitizeWebhookRecord,
+  sortEventsByCursor: () => sortEventsByCursor,
+  toQueryString: () => toQueryString,
+  truncateWebhookResponseBody: () => truncateWebhookResponseBody,
+  unregisterCustomTool: () => unregisterCustomTool,
+  validateFilterCriteria: () => validateFilterCriteria,
+  withSdkAliases: () => withSdkAliases,
+  withTextAlias: () => withTextAlias,
+  withTopicAlias: () => withTopicAlias
+});
+
+// src/opinion.ts
+function clamp01(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(1, value));
+}
+function vacuous(baseRate = 0.5) {
+  return { b: 0, d: 0, u: 1, a: clamp01(baseRate) };
+}
+function dogmatic(probability, baseRate = 0.5) {
+  const p = clamp01(probability);
+  return { b: p, d: 1 - p, u: 0, a: clamp01(baseRate) };
+}
+function opinionFromBaseRate(probability) {
+  return vacuous(clamp01(probability));
+}
+function opinionFromDogmatic(probability, baseRate = 0.5) {
+  return dogmatic(clamp01(probability), clamp01(baseRate));
+}
+function opinionFromProjected(probability, uncertainty, baseRate = 0.5) {
+  const p = clamp01(probability);
+  const u = clamp01(uncertainty);
+  const remainingMass = 1 - u;
+  return {
+    b: p * remainingMass,
+    d: (1 - p) * remainingMass,
+    u,
+    a: clamp01(baseRate)
+  };
+}
 
 // src/coreClient.ts
 var LucernApiError = class extends Error {
@@ -998,31 +1195,168 @@ function createAuditClient(config = {}) {
 }
 
 // src/beliefsClient.ts
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function clamp012(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function normalizeOpinionTuple(record) {
+  const opinion = asRecord2(record.opinion);
+  const rawBelief = readNumber(opinion.b) ?? readNumber(record.belief);
+  const rawDisbelief = readNumber(opinion.d) ?? readNumber(record.disbelief);
+  const rawUncertainty = readNumber(opinion.u) ?? readNumber(record.uncertainty);
+  const rawBaseRate = readNumber(opinion.a) ?? readNumber(record.baseRate);
+  if (rawBelief === void 0 && rawDisbelief === void 0 && rawUncertainty === void 0) {
+    const projected = clamp012(readNumber(record.confidence) ?? 0);
+    return {
+      b: projected,
+      d: 1 - projected,
+      u: 0,
+      a: 0.5
+    };
+  }
+  return {
+    b: clamp012(rawBelief ?? 0),
+    d: clamp012(rawDisbelief ?? 0),
+    u: clamp012(rawUncertainty ?? 0),
+    a: clamp012(rawBaseRate ?? 0.5)
+  };
+}
+function mapOpinionHistoryEntriesFromGatewayData(payload) {
+  const entries = Array.isArray(payload.entries) ? payload.entries : [];
+  return entries.map((value) => {
+    const record = asRecord2(value);
+    const tuple = normalizeOpinionTuple(record);
+    const projected = readNumber(record.confidence) ?? clamp012(tuple.b + tuple.a * tuple.u);
+    const triggeringEvidenceId = readString(record.triggeringEvidenceId);
+    const triggeringWorktreeId = readString(record.triggeringWorktreeId);
+    return {
+      t: readNumber(record.timestamp) ?? readNumber(record.assessedAt) ?? 0,
+      b: tuple.b,
+      d: tuple.d,
+      u: tuple.u,
+      a: tuple.a,
+      P: clamp012(projected),
+      trigger: readString(record.trigger) ?? "manual",
+      ...triggeringEvidenceId ? {
+        triggeringRef: {
+          kind: "evidence",
+          id: triggeringEvidenceId
+        }
+      } : triggeringWorktreeId ? {
+        triggeringRef: {
+          kind: "worktree",
+          id: triggeringWorktreeId
+        }
+      } : {},
+      ...readString(record.rationale) ? { rationale: readString(record.rationale) } : {},
+      ...readString(record.userId) ? { userId: readString(record.userId) } : {},
+      ...readString(record.slOperator) ? { slOperator: readString(record.slOperator) } : {}
+    };
+  }).sort((left, right) => left.t - right.t);
+}
+function normalizeModulateConfidenceInput(input) {
+  const opinion = "opinion" in input ? input.opinion : input.interpretation === "base_rate" ? opinionFromBaseRate(input.confidence) : input.interpretation === "dogmatic" ? opinionFromDogmatic(input.confidence, input.baseRate) : opinionFromProjected(
+    input.confidence,
+    input.uncertainty,
+    input.baseRate
+  );
+  return {
+    belief: opinion.b,
+    disbelief: opinion.d,
+    uncertainty: opinion.u,
+    baseRate: opinion.a,
+    trigger: input.trigger,
+    rationale: input.rationale,
+    maxInlinePropagationTargets: input.maxInlinePropagationTargets
+  };
+}
 function createBeliefsClient(config = {}) {
   const gateway = createGatewayRequestClient(config);
+  function requireBaseRate2(value) {
+    const baseRate = readNumber(value);
+    if (baseRate === void 0) {
+      throw new Error("baseRate is required for belief creation.");
+    }
+    if (baseRate < 0 || baseRate > 1) {
+      throw new Error("baseRate must be within [0, 1].");
+    }
+    return baseRate;
+  }
+  const modulateConfidence = async (beliefId, input, idempotencyKey) => gateway.request({
+    path: `/api/platform/v1/beliefs/${encodeURIComponent(beliefId)}/confidence`,
+    method: "POST",
+    body: normalizeModulateConfidenceInput(input),
+    idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+  });
+  async function getOpinionHistory(beliefId) {
+    const response = await gateway.request({
+      path: `/api/platform/v1/beliefs/${encodeURIComponent(beliefId)}/confidence-history`
+    });
+    return mapOpinionHistoryEntriesFromGatewayData(response.data);
+  }
   return {
     /**
      * Create a belief within a topic scope.
      */
     async createBelief(input, idempotencyKey) {
+      const baseRate = requireBaseRate2(input.baseRate);
       return gateway.request({
         path: "/api/platform/v1/beliefs",
         method: "POST",
-        body: normalizeNodeWriteInput(input),
+        body: {
+          ...normalizeNodeWriteInput(input),
+          baseRate
+        },
         idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
       });
     },
     /**
-     * Record a confidence change for an existing belief.
+     * Refine a draft belief in place.
      */
-    async modulateConfidence(beliefId, input, idempotencyKey) {
+    async refineBelief(beliefId, input, idempotencyKey) {
       return gateway.request({
-        path: `/api/platform/v1/beliefs/${encodeURIComponent(beliefId)}/confidence`,
-        method: "POST",
-        body: input,
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(beliefId)}`,
+        method: "PATCH",
+        body: normalizeNodeWriteInput(input),
         idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
       });
     },
+    /**
+     * Record a confidence change for an existing belief.
+     */
+    modulateConfidence,
+    /**
+     * Returns the belief's confidence trajectory as a chronological array.
+     *
+     * Canonical UI trend shape (what every trend component consumes):
+     *   { t: number, b: number, d: number, u: number, a: number, P: number, trigger: string, triggeringRef?: { kind: "evidence" | "worktree"; id: string } }[]
+     *
+     * Where:
+     *   t = assessedAt (epoch ms)
+     *   b, d, u, a = Opinion 4-tuple components
+     *   P = projected probability = b + a*u  (precomputed for UI convenience)
+     *   trigger = cause of the score change
+     *   triggeringRef = optional pointer to the evidence or worktree that drove the change
+     */
+    async getOpinionHistory(beliefId) {
+      return getOpinionHistory(beliefId);
+    },
+    /** @deprecated Use getOpinionHistory(). */
+    async getConfidenceHistory(beliefId) {
+      return getOpinionHistory(beliefId);
+    },
     /**
      * Fork a scored belief into a new formulation.
      */
@@ -1113,6 +1447,57 @@ function createBeliefsClient(config = {}) {
     }
   };
 }
+
+// src/sourcesClient.ts
+function createSourcesClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    async upsert(spec, idempotencyKey = randomIdempotencyKey()) {
+      return gateway.request({
+        path: "/api/platform/v1/sources/upsert",
+        method: "POST",
+        body: spec,
+        idempotencyKey
+      });
+    },
+    async get(sourceId) {
+      return gateway.request({
+        path: `/api/platform/v1/sources/${encodeURIComponent(sourceId)}`
+      });
+    }
+  };
+}
+
+// src/evidenceClient.ts
+function createEvidenceClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    async classifyEvidence(beliefId, evidenceId, classificationConfig, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/evidence/classify",
+        method: "POST",
+        body: {
+          beliefId,
+          evidenceId,
+          config: classificationConfig
+        },
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    },
+    async classifyEvidenceBatch(beliefId, evidence, classificationConfig, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/evidence/classify-batch",
+        method: "POST",
+        body: {
+          beliefId,
+          evidence,
+          config: classificationConfig
+        },
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      });
+    }
+  };
+}
 var DEFAULT_CUSTOM_NAMESPACE = "custom";
 var RESERVED_NAMESPACES = /* @__PURE__ */ new Set(["lucern"]);
 var CustomToolRegistryError = class extends Error {
@@ -1902,14 +2287,14 @@ function createIdentityClient(config = {}) {
 }
 
 // src/topicsClient.ts
-function asRecord2(value) {
+function asRecord3(value) {
   return value && typeof value === "object" ? value : {};
 }
 function cleanString2(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
 function normalizeTopicRecord(value) {
-  const record = asRecord2(value);
+  const record = asRecord3(value);
   const topicId = cleanString2(record.topicId) ?? cleanString2(record.id) ?? cleanString2(record._id);
   return withTopicAlias({
     ...record,
@@ -1934,7 +2319,7 @@ function createTopicsClient(config = {}) {
         })}`
       }).then(
         (response) => mapGatewayData(response, (data) => {
-          const record = asRecord2(data);
+          const record = asRecord3(data);
           const items = Array.isArray(record.topics) ? record.topics.map(normalizeTopicRecord) : [];
           return {
             ...createListResult(items, "topics"),
@@ -1951,7 +2336,7 @@ function createTopicsClient(config = {}) {
       }).then(
         (response) => mapGatewayData(
           response,
-          (data) => normalizeTopicRecord(asRecord2(data).topic ?? data)
+          (data) => normalizeTopicRecord(asRecord3(data).topic ?? data)
         )
       );
     },
@@ -1987,7 +2372,7 @@ function createTopicsClient(config = {}) {
         )}`
       }).then(
         (response) => mapGatewayData(response, (data) => {
-          const record = asRecord2(data);
+          const record = asRecord3(data);
           return {
             tree: Array.isArray(record.tree) ? record.tree.map(normalizeTopicTreeNode) : []
           };
@@ -2021,6 +2406,22 @@ function createTopicsClient(config = {}) {
 }
 
 // src/gatewayFacades.ts
+function normalizeBeliefConfidenceInput(input) {
+  const opinion = "opinion" in input ? input.opinion : input.interpretation === "base_rate" ? opinionFromBaseRate(input.confidence) : input.interpretation === "dogmatic" ? opinionFromDogmatic(input.confidence, input.baseRate) : opinionFromProjected(
+    input.confidence,
+    input.uncertainty,
+    input.baseRate
+  );
+  return {
+    belief: opinion.b,
+    disbelief: opinion.d,
+    uncertainty: opinion.u,
+    baseRate: opinion.a,
+    trigger: input.trigger,
+    rationale: input.rationale,
+    maxInlinePropagationTargets: input.maxInlinePropagationTargets
+  };
+}
 function serializeTypes(types) {
   return Array.isArray(types) && types.length > 0 ? types.join(",") : void 0;
 }
@@ -2072,7 +2473,7 @@ function createBeliefsFacade(config = {}) {
       return gateway.request({
         path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/confidence`,
         method: "POST",
-        body: input,
+        body: normalizeBeliefConfidenceInput(input),
         idempotencyKey
       });
     },
@@ -2150,6 +2551,11 @@ function createBeliefsFacade(config = {}) {
         path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/confidence-history`
       });
     },
+    async opinionHistory(id) {
+      return gateway.request({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/confidence-history`
+      });
+    },
     async createContract(id, input, idempotencyKey = randomIdempotencyKey()) {
       return gateway.request({
         path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/contracts`,
@@ -3370,199 +3776,589 @@ function createLearningClient(config = {}) {
   };
 }
 
-// src/mcpParityClient.ts
-function withSdkSessionId(args, sessionId) {
+// src/generated/functionSurface.ts
+var FUNCTION_SURFACE_METHOD_PATHS = [
+  "answers.answerQuestion",
+  "answers.createAnswer",
+  "answers.getAnswer",
+  "beliefs.archiveBelief",
+  "beliefs.bisectConfidence",
+  "beliefs.createBelief",
+  "beliefs.forkBelief",
+  "beliefs.getBelief",
+  "beliefs.getConfidenceHistory",
+  "beliefs.listBeliefs",
+  "beliefs.modulateConfidence",
+  "beliefs.refineBelief",
+  "beliefs.searchBeliefs",
+  "bootstrap.generateSessionHandoff",
+  "coding.getChangeHistory",
+  "coding.getCodeContext",
+  "coding.getFailureLog",
+  "coding.recordAttempt",
+  "context.analyzeTopicDensity",
+  "context.applyAutoBranching",
+  "context.compileContext",
+  "context.discover",
+  "context.discoverEntityConnections",
+  "context.getLatticeCoverage",
+  "context.recordScopeLearning",
+  "context.seedBeliefLattice",
+  "context.triggerBeliefReview",
+  "contracts.createEpistemicContract",
+  "contracts.evaluateContract",
+  "contracts.getContractStatus",
+  "contradictions.flagContradiction",
+  "coordination.broadcastMessage",
+  "coordination.claimFiles",
+  "coordination.endSession",
+  "coordination.getAgentInbox",
+  "coordination.heartbeatSession",
+  "coordination.listActiveSessions",
+  "coordination.registerSession",
+  "coordination.sendAgentMessage",
+  "edges.createEdge",
+  "edges.queryLineage",
+  "evidence.addEvidence",
+  "evidence.createEvidence",
+  "evidence.getEvidence",
+  "evidence.linkEvidence",
+  "evidence.linkEvidenceToBelief",
+  "evidence.linkEvidenceToQuestion",
+  "evidence.listEvidence",
+  "evidence.searchEvidence",
+  "graph.detectConfirmationBias",
+  "graph.findContradictions",
+  "graph.getGraphGaps",
+  "graph.getGraphNeighborhood",
+  "graph.getGraphStructureAnalysis",
+  "graph.getTopicCoverage",
+  "graph.traceEntityImpact",
+  "graph.traverseGraph",
+  "identity.checkPermission",
+  "identity.filterByPermission",
+  "identity.whoami",
+  "judgments.getAuditTrail",
+  "judgments.recordJudgment",
+  "lenses.applyLensToTopic",
+  "lenses.createLens",
+  "lenses.listLenses",
+  "lenses.removeLensFromTopic",
+  "observations.getObservationContext",
+  "observations.ingestObservation",
+  "ontologies.applyOntology",
+  "ontologies.archiveOntology",
+  "ontologies.createOntology",
+  "ontologies.createOntologyVersion",
+  "ontologies.deprecateOntologyVersion",
+  "ontologies.getOntology",
+  "ontologies.listOntologies",
+  "ontologies.matchEntityType",
+  "ontologies.publishOntologyVersion",
+  "ontologies.resolveEffectiveOntology",
+  "ontologies.updateOntology",
+  "policy.manageWritePolicy",
+  "questions.archiveQuestion",
+  "questions.createQuestion",
+  "questions.findMissingQuestions",
+  "questions.getFalsificationQuestions",
+  "questions.getHighPriorityQuestions",
+  "questions.getQuestion",
+  "questions.listQuestions",
+  "questions.refineQuestion",
+  "questions.updateQuestionStatus",
+  "tasks.completeTask",
+  "tasks.createTask",
+  "tasks.listTasks",
+  "tasks.updateTask",
+  "topics.createTopic",
+  "topics.getTopic",
+  "topics.getTopicTree",
+  "topics.listTopics",
+  "topics.updateTopic",
+  "worktrees.activateWorktree",
+  "worktrees.addWorktree",
+  "worktrees.listAllWorktrees",
+  "worktrees.listWorktrees",
+  "worktrees.merge",
+  "worktrees.openPullRequest",
+  "worktrees.pipelineSnapshot",
+  "worktrees.push",
+  "worktrees.updateWorktreeMetadata",
+  "worktrees.updateWorktreeTargets"
+];
+var CONTRACTS = {
+  "activate_worktree": { method: "POST", path: "/worktrees/activate", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "add_evidence": { method: "POST", path: "/evidence/add", kind: "mutation", idempotent: true, surfaceIntent: "compatibility" },
+  "add_worktree": { method: "POST", path: "/worktrees", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "analyze_topic_density": { method: "POST", path: "/scope/topic-density", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "answer_question": { method: "POST", path: "/questions/answer", kind: "mutation", idempotent: true, surfaceIntent: "compatibility" },
+  "apply_auto_branching": { method: "POST", path: "/scope/auto-branching", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
+  "apply_lens_to_topic": { method: "POST", path: "/lenses/apply", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "apply_ontology": { method: "POST", path: "/ontologies/apply", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "archive_belief": { method: "DELETE", path: "/beliefs", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "archive_ontology": { method: "DELETE", path: "/ontologies", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
+  "archive_question": { method: "DELETE", path: "/questions", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "bisect_confidence": { method: "POST", path: "/beliefs/confidence/bisect", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "broadcast_message": { method: "POST", path: "/coordination/messages/broadcast", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "check_permission": { method: "POST", path: "/identity/check-permission", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "claim_files": { method: "POST", path: "/coordination/file-claims", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "compile_context": { method: "POST", path: "/context/compile", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "complete_task": { method: "POST", path: "/tasks/complete", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "create_answer": { method: "POST", path: "/answers", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "create_belief": { method: "POST", path: "/beliefs", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "create_edge": { method: "POST", path: "/edges", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
+  "create_epistemic_contract": { method: "POST", path: "/contracts", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
+  "create_evidence": { method: "POST", path: "/evidence", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "create_lens": { method: "POST", path: "/lenses", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
+  "create_ontology": { method: "POST", path: "/ontologies", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
+  "create_ontology_version": { method: "POST", path: "/ontologies/versions", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
+  "create_question": { method: "POST", path: "/questions", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "create_task": { method: "POST", path: "/tasks", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "create_topic": { method: "POST", path: "/topics", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "deprecate_ontology_version": { method: "POST", path: "/ontologies/versions/deprecate", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
+  "detect_confirmation_bias": { method: "POST", path: "/graph/confirmation-bias", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "discover": { method: "POST", path: "/context/discover", kind: "query", idempotent: false, surfaceIntent: "compatibility" },
+  "discover_entity_connections": { method: "POST", path: "/context/entity-connections", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "end_session": { method: "POST", path: "/coordination/end-session", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "evaluate_contract": { method: "POST", path: "/contracts/evaluate", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
+  "filter_by_permission": { method: "POST", path: "/identity/filter-by-permission", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "find_contradictions": { method: "POST", path: "/graph/contradictions", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "find_missing_questions": { method: "POST", path: "/questions/missing", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "flag_contradiction": { method: "POST", path: "/contradictions", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
+  "fork_belief": { method: "POST", path: "/beliefs/fork", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "generate_session_handoff": { method: "POST", path: "/bootstrap/session-handoff", kind: "query", idempotent: false, surfaceIntent: "system" },
+  "get_agent_inbox": { method: "POST", path: "/coordination/messages/inbox", kind: "query", idempotent: false, surfaceIntent: "system" },
+  "get_answer": { method: "GET", path: "/answers/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "get_audit_trail": { method: "POST", path: "/judgments/audit-trail", kind: "query", idempotent: false, surfaceIntent: "system" },
+  "get_belief": { method: "GET", path: "/beliefs/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "get_change_history": { method: "POST", path: "/coding/change-history", kind: "query", idempotent: false, surfaceIntent: "system" },
+  "get_code_context": { method: "POST", path: "/coding/context", kind: "query", idempotent: false, surfaceIntent: "system" },
+  "get_confidence_history": { method: "POST", path: "/beliefs/confidence-history", kind: "query", idempotent: false, surfaceIntent: "compatibility" },
+  "get_contract_status": { method: "POST", path: "/contracts/status", kind: "query", idempotent: false, surfaceIntent: "mcp_governance" },
+  "get_evidence": { method: "GET", path: "/evidence/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "get_failure_log": { method: "POST", path: "/coding/failure-log", kind: "query", idempotent: false, surfaceIntent: "system" },
+  "get_falsification_questions": { method: "POST", path: "/questions/falsification", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "get_graph_gaps": { method: "POST", path: "/graph/gaps", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "get_graph_neighborhood": { method: "POST", path: "/graph/neighborhood", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "get_graph_structure_analysis": { method: "POST", path: "/graph/structure-analysis", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "get_high_priority_questions": { method: "POST", path: "/questions/high-priority", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "get_lattice_coverage": { method: "POST", path: "/scope/belief-lattice/coverage", kind: "query", idempotent: false, surfaceIntent: "system" },
+  "get_observation_context": { method: "POST", path: "/observations/context", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
+  "get_ontology": { method: "GET", path: "/ontologies/get", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
+  "get_question": { method: "GET", path: "/questions/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "get_topic": { method: "GET", path: "/topics/get", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "get_topic_coverage": { method: "POST", path: "/graph/topic-coverage", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "get_topic_tree": { method: "GET", path: "/topics/tree", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "heartbeat_session": { method: "POST", path: "/coordination/heartbeat-session", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "identity_whoami": { method: "GET", path: "/identity/whoami", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "ingest_observation": { method: "POST", path: "/observations/ingest", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "link_evidence": { method: "POST", path: "/evidence/link", kind: "mutation", idempotent: true, surfaceIntent: "compatibility" },
+  "link_evidence_to_belief": { method: "POST", path: "/evidence/link-belief", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "link_evidence_to_question": { method: "POST", path: "/evidence/link-question", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "list_active_sessions": { method: "POST", path: "/coordination/active-sessions", kind: "query", idempotent: false, surfaceIntent: "system" },
+  "list_all_worktrees": { method: "GET", path: "/worktrees/all", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
+  "list_beliefs": { method: "GET", path: "/beliefs", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "list_evidence": { method: "GET", path: "/evidence", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "list_lenses": { method: "GET", path: "/lenses", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
+  "list_ontologies": { method: "GET", path: "/ontologies", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
+  "list_questions": { method: "GET", path: "/questions", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "list_tasks": { method: "GET", path: "/tasks", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
+  "list_topics": { method: "GET", path: "/topics", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "list_worktrees": { method: "GET", path: "/worktrees", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
+  "manage_write_policy": { method: "POST", path: "/policy/write-policy/manage", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
+  "match_entity_type": { method: "POST", path: "/ontologies/match-entity-type", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
+  "merge": { method: "POST", path: "/worktrees/merge", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "modulate_confidence": { method: "POST", path: "/beliefs/confidence", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "open_pull_request": { method: "POST", path: "/worktrees/open-pull-request", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "pipeline_snapshot": { method: "POST", path: "/worktrees/pipeline-snapshot", kind: "query", idempotent: false, surfaceIntent: "system" },
+  "publish_ontology_version": { method: "POST", path: "/ontologies/versions/publish", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
+  "push": { method: "POST", path: "/worktrees/push", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "query_lineage": { method: "POST", path: "/edges/lineage", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "record_attempt": { method: "POST", path: "/coding/attempts", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "record_judgment": { method: "POST", path: "/judgments", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "record_scope_learning": { method: "POST", path: "/scope/learnings", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "refine_belief": { method: "PATCH", path: "/beliefs/refine", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "refine_question": { method: "PATCH", path: "/questions/refine", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "register_session": { method: "POST", path: "/coordination/register-session", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "remove_lens_from_topic": { method: "DELETE", path: "/lenses/apply", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "resolve_effective_ontology": { method: "POST", path: "/ontologies/effective", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
+  "search_beliefs": { method: "POST", path: "/beliefs/search", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "search_evidence": { method: "POST", path: "/evidence/search", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "seed_belief_lattice": { method: "POST", path: "/scope/belief-lattice/seed", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "send_agent_message": { method: "POST", path: "/coordination/messages/send", kind: "mutation", idempotent: true, surfaceIntent: "system" },
+  "trace_entity_impact": { method: "POST", path: "/graph/trace-entity-impact", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "traverse_graph": { method: "POST", path: "/graph/traverse", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
+  "trigger_belief_review": { method: "POST", path: "/context/belief-review", kind: "mutation", idempotent: true, surfaceIntent: "mcp_analysis" },
+  "update_ontology": { method: "PATCH", path: "/ontologies", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
+  "update_question_status": { method: "PATCH", path: "/questions/status", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "update_task": { method: "PATCH", path: "/tasks", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "update_topic": { method: "PATCH", path: "/topics", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "update_worktree_metadata": { method: "PATCH", path: "/worktrees/metadata", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
+  "update_worktree_targets": { method: "PATCH", path: "/worktrees/targets", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" }
+};
+function createSessionId() {
+  return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : randomIdempotencyKey();
+}
+function withSdkSessionId(input, sessionId) {
   return {
-    ...args ?? {},
-    __sdkSessionId: sessionId
+    ...input,
+    __sdkSessionId: typeof input.__sdkSessionId === "string" ? input.__sdkSessionId : sessionId
   };
 }
-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 toFunctionSurfaceQuery(input) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0) {
+      continue;
+    }
+    const serialized2 = typeof value === "string" ? value : JSON.stringify(value);
+    if (serialized2 !== void 0) {
+      params.set(key, serialized2);
+    }
   }
-  function executeMutation(toolName, args, idempotencyKey) {
+  const serialized = params.toString();
+  return serialized ? `?${serialized}` : "";
+}
+function createFunctionSurfaceClient(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  const sessionId = createSessionId();
+  function execute(name, input, idempotencyKey) {
+    const contract = CONTRACTS[name];
+    const payload = withSdkSessionId(input, sessionId);
+    const path = contract.method === "GET" ? `${contract.path}${toFunctionSurfaceQuery(payload)}` : contract.path;
     return gateway.request({
-      path: `/api/platform/v1/mcp-tools/${encodeURIComponent(toolName)}`,
-      method: "POST",
-      body: withSdkSessionId(args, sessionId),
-      idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      path: `/api/platform/v1${path}`,
+      method: contract.method,
+      body: contract.method === "GET" ? void 0 : payload,
+      idempotencyKey: contract.kind !== "query" && Boolean(contract.idempotent) ? idempotencyKey ?? randomIdempotencyKey() : void 0
     });
   }
   return {
     sessionId,
-    listTopics(args = {}) {
-      return executeRead("list_topics", args);
+    activateWorktree(input = {}, idempotencyKey) {
+      return execute("activate_worktree", input, idempotencyKey);
     },
-    createTopic(args, idempotencyKey) {
-      return executeMutation("create_topic", args, idempotencyKey);
+    addEvidence(input = {}, idempotencyKey) {
+      return execute("add_evidence", input, idempotencyKey);
     },
-    getTopic(args) {
-      return executeRead("get_topic", args);
+    addWorktree(input = {}, idempotencyKey) {
+      return execute("add_worktree", input, idempotencyKey);
     },
-    getTopicTree(args) {
-      return executeRead("get_topic_tree", args);
+    analyzeTopicDensity(input = {}, idempotencyKey) {
+      return execute("analyze_topic_density", input, idempotencyKey);
     },
-    activateWorktree(args, idempotencyKey) {
-      return executeMutation("activate_worktree", args, idempotencyKey);
+    answerQuestion(input = {}, idempotencyKey) {
+      return execute("answer_question", input, idempotencyKey);
     },
-    updateWorktreeMetadata(args, idempotencyKey) {
-      return executeMutation("update_worktree_metadata", args, idempotencyKey);
+    applyAutoBranching(input = {}, idempotencyKey) {
+      return execute("apply_auto_branching", input, idempotencyKey);
     },
-    updateWorktreeTargets(args, idempotencyKey) {
-      return executeMutation("update_worktree_targets", args, idempotencyKey);
+    applyLensToTopic(input = {}, idempotencyKey) {
+      return execute("apply_lens_to_topic", input, idempotencyKey);
     },
-    listAllWorktrees(args = {}) {
-      return executeRead("list_all_worktrees", args);
+    applyOntology(input = {}, idempotencyKey) {
+      return execute("apply_ontology", input, idempotencyKey);
     },
-    pipelineSnapshot(args) {
-      return executeRead("pipeline_snapshot", args);
+    archiveBelief(input = {}, idempotencyKey) {
+      return execute("archive_belief", input, idempotencyKey);
     },
-    recordScopeLearning(args, idempotencyKey) {
-      return executeMutation("record_scope_learning", args, idempotencyKey);
+    archiveOntology(input = {}, idempotencyKey) {
+      return execute("archive_ontology", input, idempotencyKey);
     },
-    discover(args) {
-      return executeRead("discover", args);
+    archiveQuestion(input = {}, idempotencyKey) {
+      return execute("archive_question", input, idempotencyKey);
     },
-    analyzeTopicDensity(args) {
-      return executeRead("analyze_topic_density", args);
+    bisectConfidence(input = {}, idempotencyKey) {
+      return execute("bisect_confidence", input, idempotencyKey);
     },
-    applyAutoBranching(args, idempotencyKey) {
-      return executeMutation("apply_auto_branching", args, idempotencyKey);
+    broadcastMessage(input = {}, idempotencyKey) {
+      return execute("broadcast_message", input, idempotencyKey);
     },
-    seedBeliefLattice(args = {}, idempotencyKey) {
-      return executeMutation("seed_belief_lattice", args, idempotencyKey);
+    checkPermission(input = {}, idempotencyKey) {
+      return execute("check_permission", input, idempotencyKey);
     },
-    getLatticeCoverage(args = {}) {
-      return executeRead("get_lattice_coverage", args);
+    claimFiles(input = {}, idempotencyKey) {
+      return execute("claim_files", input, idempotencyKey);
     },
-    matchEntityType(args) {
-      return executeRead("match_entity_type", args);
+    compileContext(input = {}, idempotencyKey) {
+      return execute("compile_context", input, idempotencyKey);
     },
-    discoverEntityConnections(args) {
-      return executeRead("discover_entity_connections", args);
+    completeTask(input = {}, idempotencyKey) {
+      return execute("complete_task", input, idempotencyKey);
     },
-    triggerBeliefReview(args, idempotencyKey) {
-      return executeMutation("trigger_belief_review", args, idempotencyKey);
+    createAnswer(input = {}, idempotencyKey) {
+      return execute("create_answer", input, idempotencyKey);
     },
-    listOntologies(args = {}) {
-      return executeRead("list_ontologies", args);
+    createBelief(input = {}, idempotencyKey) {
+      return execute("create_belief", input, idempotencyKey);
     },
-    getOntology(args) {
-      return executeRead("get_ontology", args);
+    createEdge(input = {}, idempotencyKey) {
+      return execute("create_edge", input, idempotencyKey);
     },
-    applyOntology(args, idempotencyKey) {
-      return executeMutation("apply_ontology", args, idempotencyKey);
+    createEpistemicContract(input = {}, idempotencyKey) {
+      return execute("create_epistemic_contract", input, idempotencyKey);
     },
-    createOntology(args, idempotencyKey) {
-      return executeMutation("create_ontology", args, idempotencyKey);
+    createEvidence(input = {}, idempotencyKey) {
+      return execute("create_evidence", input, idempotencyKey);
     },
-    updateOntology(args, idempotencyKey) {
-      return executeMutation("update_ontology", args, idempotencyKey);
+    createLens(input = {}, idempotencyKey) {
+      return execute("create_lens", input, idempotencyKey);
     },
-    archiveOntology(args, idempotencyKey) {
-      return executeMutation("archive_ontology", args, idempotencyKey);
+    createOntology(input = {}, idempotencyKey) {
+      return execute("create_ontology", input, idempotencyKey);
     },
-    createOntologyVersion(args, idempotencyKey) {
-      return executeMutation("create_ontology_version", args, idempotencyKey);
+    createOntologyVersion(input = {}, idempotencyKey) {
+      return execute("create_ontology_version", input, idempotencyKey);
     },
-    publishOntologyVersion(args, idempotencyKey) {
-      return executeMutation("publish_ontology_version", args, idempotencyKey);
+    createQuestion(input = {}, idempotencyKey) {
+      return execute("create_question", input, idempotencyKey);
     },
-    deprecateOntologyVersion(args, idempotencyKey) {
-      return executeMutation(
-        "deprecate_ontology_version",
-        args,
-        idempotencyKey
-      );
+    createTask(input = {}, idempotencyKey) {
+      return execute("create_task", input, idempotencyKey);
     },
-    resolveEffectiveOntology(args) {
-      return executeRead("resolve_effective_ontology", args);
+    createTopic(input = {}, idempotencyKey) {
+      return execute("create_topic", input, idempotencyKey);
     },
-    registerSession(args = {}, idempotencyKey) {
-      return executeMutation("register_session", args, idempotencyKey);
+    deprecateOntologyVersion(input = {}, idempotencyKey) {
+      return execute("deprecate_ontology_version", input, idempotencyKey);
     },
-    heartbeatSession(args = {}, idempotencyKey) {
-      return executeMutation("heartbeat_session", args, idempotencyKey);
+    detectConfirmationBias(input = {}, idempotencyKey) {
+      return execute("detect_confirmation_bias", input, idempotencyKey);
     },
-    endSession(args = {}, idempotencyKey) {
-      return executeMutation("end_session", args, idempotencyKey);
+    discover(input = {}, idempotencyKey) {
+      return execute("discover", input, idempotencyKey);
     },
-    listActiveSessions(args = {}) {
-      return executeRead("list_active_sessions", args);
+    discoverEntityConnections(input = {}, idempotencyKey) {
+      return execute("discover_entity_connections", input, idempotencyKey);
     },
-    sendAgentMessage(args, idempotencyKey) {
-      return executeMutation("send_agent_message", args, idempotencyKey);
+    endSession(input = {}, idempotencyKey) {
+      return execute("end_session", input, idempotencyKey);
     },
-    broadcastMessage(args, idempotencyKey) {
-      return executeMutation("broadcast_message", args, idempotencyKey);
+    evaluateContract(input = {}, idempotencyKey) {
+      return execute("evaluate_contract", input, idempotencyKey);
     },
-    getAgentInbox(args = {}) {
-      return executeRead("get_agent_inbox", args);
+    filterByPermission(input = {}, idempotencyKey) {
+      return execute("filter_by_permission", input, idempotencyKey);
     },
-    claimFiles(args, idempotencyKey) {
-      return executeMutation("claim_files", args, idempotencyKey);
+    findContradictions(input = {}, idempotencyKey) {
+      return execute("find_contradictions", input, idempotencyKey);
     },
-    listTasks(args) {
-      return executeRead("list_tasks", args);
+    findMissingQuestions(input = {}, idempotencyKey) {
+      return execute("find_missing_questions", input, idempotencyKey);
     },
-    createAnswer(args, idempotencyKey) {
-      return executeMutation("create_answer", args, idempotencyKey);
+    flagContradiction(input = {}, idempotencyKey) {
+      return execute("flag_contradiction", input, idempotencyKey);
     },
-    getAnswer(args) {
-      return executeRead("get_answer", args);
+    forkBelief(input = {}, idempotencyKey) {
+      return execute("fork_belief", input, idempotencyKey);
     },
-    flagContradiction(args, idempotencyKey) {
-      return executeMutation("flag_contradiction", args, idempotencyKey);
+    generateSessionHandoff(input = {}, idempotencyKey) {
+      return execute("generate_session_handoff", input, idempotencyKey);
     },
-    ingestObservation(args, idempotencyKey) {
-      return executeMutation("ingest_observation", args, idempotencyKey);
+    getAgentInbox(input = {}, idempotencyKey) {
+      return execute("get_agent_inbox", input, idempotencyKey);
     },
-    getObservationContext(args) {
-      return executeRead("get_observation_context", args);
+    getAnswer(input = {}, idempotencyKey) {
+      return execute("get_answer", input, idempotencyKey);
     },
-    getCodeContext(args) {
-      return executeRead("get_code_context", args);
+    getAuditTrail(input = {}, idempotencyKey) {
+      return execute("get_audit_trail", input, idempotencyKey);
     },
-    getChangeHistory(args) {
-      return executeRead("get_change_history", args);
+    getBelief(input = {}, idempotencyKey) {
+      return execute("get_belief", input, idempotencyKey);
     },
-    recordAttempt(args, idempotencyKey) {
-      return executeMutation("record_attempt", args, idempotencyKey);
+    getChangeHistory(input = {}, idempotencyKey) {
+      return execute("get_change_history", input, idempotencyKey);
     },
-    getFailureLog(args) {
-      return executeRead("get_failure_log", args);
+    getCodeContext(input = {}, idempotencyKey) {
+      return execute("get_code_context", input, idempotencyKey);
     },
-    createEpistemicContract(args, idempotencyKey) {
-      return executeMutation(
-        "create_epistemic_contract",
-        args,
-        idempotencyKey
-      );
+    getConfidenceHistory(input = {}, idempotencyKey) {
+      return execute("get_confidence_history", input, idempotencyKey);
+    },
+    getContractStatus(input = {}, idempotencyKey) {
+      return execute("get_contract_status", input, idempotencyKey);
+    },
+    getEvidence(input = {}, idempotencyKey) {
+      return execute("get_evidence", input, idempotencyKey);
+    },
+    getFailureLog(input = {}, idempotencyKey) {
+      return execute("get_failure_log", input, idempotencyKey);
+    },
+    getFalsificationQuestions(input = {}, idempotencyKey) {
+      return execute("get_falsification_questions", input, idempotencyKey);
+    },
+    getGraphGaps(input = {}, idempotencyKey) {
+      return execute("get_graph_gaps", input, idempotencyKey);
+    },
+    getGraphNeighborhood(input = {}, idempotencyKey) {
+      return execute("get_graph_neighborhood", input, idempotencyKey);
+    },
+    getGraphStructureAnalysis(input = {}, idempotencyKey) {
+      return execute("get_graph_structure_analysis", input, idempotencyKey);
+    },
+    getHighPriorityQuestions(input = {}, idempotencyKey) {
+      return execute("get_high_priority_questions", input, idempotencyKey);
+    },
+    getLatticeCoverage(input = {}, idempotencyKey) {
+      return execute("get_lattice_coverage", input, idempotencyKey);
+    },
+    getObservationContext(input = {}, idempotencyKey) {
+      return execute("get_observation_context", input, idempotencyKey);
+    },
+    getOntology(input = {}, idempotencyKey) {
+      return execute("get_ontology", input, idempotencyKey);
+    },
+    getQuestion(input = {}, idempotencyKey) {
+      return execute("get_question", input, idempotencyKey);
+    },
+    getTopic(input = {}, idempotencyKey) {
+      return execute("get_topic", input, idempotencyKey);
+    },
+    getTopicCoverage(input = {}, idempotencyKey) {
+      return execute("get_topic_coverage", input, idempotencyKey);
+    },
+    getTopicTree(input = {}, idempotencyKey) {
+      return execute("get_topic_tree", input, idempotencyKey);
+    },
+    heartbeatSession(input = {}, idempotencyKey) {
+      return execute("heartbeat_session", input, idempotencyKey);
+    },
+    whoami(input = {}, idempotencyKey) {
+      return execute("identity_whoami", input, idempotencyKey);
+    },
+    ingestObservation(input = {}, idempotencyKey) {
+      return execute("ingest_observation", input, idempotencyKey);
+    },
+    linkEvidence(input = {}, idempotencyKey) {
+      return execute("link_evidence", input, idempotencyKey);
+    },
+    linkEvidenceToBelief(input = {}, idempotencyKey) {
+      return execute("link_evidence_to_belief", input, idempotencyKey);
+    },
+    linkEvidenceToQuestion(input = {}, idempotencyKey) {
+      return execute("link_evidence_to_question", input, idempotencyKey);
+    },
+    listActiveSessions(input = {}, idempotencyKey) {
+      return execute("list_active_sessions", input, idempotencyKey);
+    },
+    listAllWorktrees(input = {}, idempotencyKey) {
+      return execute("list_all_worktrees", input, idempotencyKey);
+    },
+    listBeliefs(input = {}, idempotencyKey) {
+      return execute("list_beliefs", input, idempotencyKey);
+    },
+    listEvidence(input = {}, idempotencyKey) {
+      return execute("list_evidence", input, idempotencyKey);
+    },
+    listLenses(input = {}, idempotencyKey) {
+      return execute("list_lenses", input, idempotencyKey);
+    },
+    listOntologies(input = {}, idempotencyKey) {
+      return execute("list_ontologies", input, idempotencyKey);
+    },
+    listQuestions(input = {}, idempotencyKey) {
+      return execute("list_questions", input, idempotencyKey);
+    },
+    listTasks(input = {}, idempotencyKey) {
+      return execute("list_tasks", input, idempotencyKey);
+    },
+    listTopics(input = {}, idempotencyKey) {
+      return execute("list_topics", input, idempotencyKey);
+    },
+    listWorktrees(input = {}, idempotencyKey) {
+      return execute("list_worktrees", input, idempotencyKey);
     },
-    evaluateContract(args, idempotencyKey) {
-      return executeMutation("evaluate_contract", args, idempotencyKey);
+    manageWritePolicy(input = {}, idempotencyKey) {
+      return execute("manage_write_policy", input, idempotencyKey);
     },
-    getContractStatus(args) {
-      return executeRead("get_contract_status", args);
+    matchEntityType(input = {}, idempotencyKey) {
+      return execute("match_entity_type", input, idempotencyKey);
     },
-    checkPermission(args) {
-      return executeRead("check_permission", args);
+    merge(input = {}, idempotencyKey) {
+      return execute("merge", input, idempotencyKey);
     },
-    filterByPermission(args) {
-      return executeRead("filter_by_permission", args);
+    modulateConfidence(input = {}, idempotencyKey) {
+      return execute("modulate_confidence", input, idempotencyKey);
     },
-    manageWritePolicy(args, idempotencyKey) {
-      return args.action === "set" ? executeMutation("manage_write_policy", args, idempotencyKey) : executeRead("manage_write_policy", args);
+    openPullRequest(input = {}, idempotencyKey) {
+      return execute("open_pull_request", input, idempotencyKey);
     },
-    generateSessionHandoff(args) {
-      return executeRead("generate_session_handoff", args);
+    pipelineSnapshot(input = {}, idempotencyKey) {
+      return execute("pipeline_snapshot", input, idempotencyKey);
+    },
+    publishOntologyVersion(input = {}, idempotencyKey) {
+      return execute("publish_ontology_version", input, idempotencyKey);
+    },
+    push(input = {}, idempotencyKey) {
+      return execute("push", input, idempotencyKey);
+    },
+    queryLineage(input = {}, idempotencyKey) {
+      return execute("query_lineage", input, idempotencyKey);
+    },
+    recordAttempt(input = {}, idempotencyKey) {
+      return execute("record_attempt", input, idempotencyKey);
+    },
+    recordJudgment(input = {}, idempotencyKey) {
+      return execute("record_judgment", input, idempotencyKey);
+    },
+    recordScopeLearning(input = {}, idempotencyKey) {
+      return execute("record_scope_learning", input, idempotencyKey);
+    },
+    refineBelief(input = {}, idempotencyKey) {
+      return execute("refine_belief", input, idempotencyKey);
+    },
+    refineQuestion(input = {}, idempotencyKey) {
+      return execute("refine_question", input, idempotencyKey);
+    },
+    registerSession(input = {}, idempotencyKey) {
+      return execute("register_session", input, idempotencyKey);
+    },
+    removeLensFromTopic(input = {}, idempotencyKey) {
+      return execute("remove_lens_from_topic", input, idempotencyKey);
+    },
+    resolveEffectiveOntology(input = {}, idempotencyKey) {
+      return execute("resolve_effective_ontology", input, idempotencyKey);
+    },
+    searchBeliefs(input = {}, idempotencyKey) {
+      return execute("search_beliefs", input, idempotencyKey);
+    },
+    searchEvidence(input = {}, idempotencyKey) {
+      return execute("search_evidence", input, idempotencyKey);
+    },
+    seedBeliefLattice(input = {}, idempotencyKey) {
+      return execute("seed_belief_lattice", input, idempotencyKey);
+    },
+    sendAgentMessage(input = {}, idempotencyKey) {
+      return execute("send_agent_message", input, idempotencyKey);
+    },
+    traceEntityImpact(input = {}, idempotencyKey) {
+      return execute("trace_entity_impact", input, idempotencyKey);
+    },
+    traverseGraph(input = {}, idempotencyKey) {
+      return execute("traverse_graph", input, idempotencyKey);
+    },
+    triggerBeliefReview(input = {}, idempotencyKey) {
+      return execute("trigger_belief_review", input, idempotencyKey);
+    },
+    updateOntology(input = {}, idempotencyKey) {
+      return execute("update_ontology", input, idempotencyKey);
+    },
+    updateQuestionStatus(input = {}, idempotencyKey) {
+      return execute("update_question_status", input, idempotencyKey);
+    },
+    updateTask(input = {}, idempotencyKey) {
+      return execute("update_task", input, idempotencyKey);
+    },
+    updateTopic(input = {}, idempotencyKey) {
+      return execute("update_topic", input, idempotencyKey);
+    },
+    updateWorktreeMetadata(input = {}, idempotencyKey) {
+      return execute("update_worktree_metadata", input, idempotencyKey);
+    },
+    updateWorktreeTargets(input = {}, idempotencyKey) {
+      return execute("update_worktree_targets", input, idempotencyKey);
     }
   };
 }
@@ -4629,13 +5425,24 @@ function requireText(args) {
   }
   return text;
 }
+function requireBaseRate(args) {
+  if (typeof args.baseRate !== "number" || !Number.isFinite(args.baseRate)) {
+    throw new Error("baseRate is required.");
+  }
+  if (args.baseRate < 0 || args.baseRate > 1) {
+    throw new Error("baseRate must be within [0, 1].");
+  }
+  return args.baseRate;
+}
 function exposeGatewayData(response) {
   return Object.assign({}, response, response.data);
 }
 function createLucernClient(config = {}) {
   const gatewayConfig = toGatewayConfig(config);
   const beliefsClient = createBeliefsClient(gatewayConfig);
+  const sourcesClient = createSourcesClient(gatewayConfig);
   const beliefsFacade = createBeliefsFacade(gatewayConfig);
+  const evidenceClient = createEvidenceClient(gatewayConfig);
   const graphClient = createGraphClient(gatewayConfig);
   const graphFacade = createGraphFacade(gatewayConfig);
   const decisionsClient = createDecisionsClient(gatewayConfig);
@@ -4659,7 +5466,7 @@ function createLucernClient(config = {}) {
   const worktreesFacade = createWorktreesFacade(gatewayConfig);
   const policyClient = createPolicyClient(gatewayConfig);
   const ontologyClient = createOntologyClient(gatewayConfig);
-  const mcpParityClient = createMcpParityClient(gatewayConfig);
+  const functionSurfaceClient = createFunctionSurfaceClient(gatewayConfig);
   const packsClient = createPacksClient(gatewayConfig);
   const reportsClient = createReportsClient(gatewayConfig);
   const learningClient = createLearningClient(gatewayConfig);
@@ -4739,7 +5546,6 @@ function createLucernClient(config = {}) {
     }
   );
   async function createEvidenceCompat(args) {
-    const topicId = requireTopicId(args);
     const text = resolveText(args);
     if (!text) {
       throw new Error("text is required");
@@ -4749,7 +5555,7 @@ function createLucernClient(config = {}) {
       ...args.supports?.reasoning ? { rationale: args.supports.reasoning } : {}
     };
     return evidenceFacade.create({
-      topicId,
+      topicId: resolveTopicId(args),
       text,
       source: args.source ?? args.sourceUrl,
       targetId: args.targetId ?? args.supports?.nodeId,
@@ -4876,6 +5682,10 @@ function createLucernClient(config = {}) {
   async function getConfidenceHistory(nodeId) {
     return beliefsFacade.confidenceHistory(nodeId).then(exposeGatewayData);
   }
+  async function getOpinionHistory(nodeId) {
+    const response = await beliefsFacade.opinionHistory(nodeId);
+    return mapOpinionHistoryEntriesFromGatewayData(response.data);
+  }
   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) => {
@@ -5056,11 +5866,12 @@ function createLucernClient(config = {}) {
     beliefs: {
       create(input) {
         return beliefsFacade.create({
-          topicId: requireTopicId(input),
+          topicId: resolveTopicId(input),
           text: requireText(input),
           rationale: input.rationale,
           worktreeId: input.worktreeId,
           pillar: input.pillar,
+          baseRate: requireBaseRate(input),
           sourceBeliefIds: input.sourceBeliefIds,
           sourceType: input.sourceType,
           beliefType: input.beliefType,
@@ -5134,6 +5945,9 @@ function createLucernClient(config = {}) {
       confidenceHistory(nodeId) {
         return beliefsFacade.confidenceHistory(nodeId).then(exposeGatewayData);
       },
+      opinionHistory(nodeId) {
+        return getOpinionHistory(nodeId);
+      },
       createContract(nodeId, input) {
         return beliefsFacade.createContract(nodeId, input).then(exposeGatewayData);
       },
@@ -5265,6 +6079,12 @@ function createLucernClient(config = {}) {
           beliefId: args.beliefId
         }));
       },
+      classifyEvidence(beliefId, evidenceId, config2, idempotencyKey) {
+        return evidenceClient.classifyEvidence(beliefId, evidenceId, config2, idempotencyKey).then(exposeGatewayData);
+      },
+      classifyEvidenceBatch(beliefId, evidence, config2, idempotencyKey) {
+        return evidenceClient.classifyEvidenceBatch(beliefId, evidence, config2, idempotencyKey).then(exposeGatewayData);
+      },
       updateStatus(input, idempotencyKey) {
         return evidenceFacade.updateStatus(input, idempotencyKey).then(exposeGatewayData);
       },
@@ -5281,10 +6101,18 @@ function createLucernClient(config = {}) {
         return evidenceFacade.updateVerificationStatus(input, idempotencyKey).then(exposeGatewayData);
       }
     },
+    sources: {
+      upsert(input, idempotencyKey) {
+        return sourcesClient.upsert(input, idempotencyKey).then(exposeGatewayData);
+      },
+      get(sourceId) {
+        return sourcesClient.get(sourceId).then(exposeGatewayData);
+      }
+    },
     questions: {
       create(args) {
         return questionsFacade.create({
-          topicId: requireTopicId(args),
+          topicId: resolveTopicId(args),
           text: args.text,
           priority: args.priority,
           linkedBeliefId: args.linkedBeliefId,
@@ -5317,10 +6145,22 @@ function createLucernClient(config = {}) {
         }).then(exposeGatewayData);
       },
       batchCreate(input, idempotencyKey) {
-        return questionsFacade.batchCreate(input, idempotencyKey).then(exposeGatewayData);
+        return questionsFacade.batchCreate(
+          {
+            ...input,
+            topicId: resolveTopicId(input)
+          },
+          idempotencyKey
+        ).then(exposeGatewayData);
       },
       add(input, idempotencyKey) {
-        return questionsFacade.add(input, idempotencyKey).then(exposeGatewayData);
+        return questionsFacade.add(
+          {
+            ...input,
+            topicId: resolveTopicId(input)
+          },
+          idempotencyKey
+        ).then(exposeGatewayData);
       },
       updatePriority(input, idempotencyKey) {
         return questionsFacade.updatePriority(input, idempotencyKey).then(exposeGatewayData);
@@ -5406,6 +6246,7 @@ function createLucernClient(config = {}) {
       },
       queryLineage,
       getConfidenceHistory,
+      getOpinionHistory,
       getAuditTrail,
       traverse(args) {
         return graphFacade.traverse({
@@ -5634,7 +6475,7 @@ function createLucernClient(config = {}) {
         return workflowClient.openPullRequest(worktreeId, input);
       },
       pipelineSnapshot(topicId) {
-        return mcpParityClient.pipelineSnapshot({ topicId });
+        return functionSurfaceClient.pipelineSnapshot({ topicId });
       },
       complete(input, idempotencyKey) {
         return worktreesFacade.complete(input, idempotencyKey);
@@ -5670,23 +6511,23 @@ function createLucernClient(config = {}) {
       compile(topicId, input = {}) {
         return contextClient.compile(topicId, input);
       },
-      recordScopeLearning(input) {
-        return mcpParityClient.recordScopeLearning(input);
+      recordScopeLearning(input, idempotencyKey) {
+        return functionSurfaceClient.recordScopeLearning(input, idempotencyKey);
       },
       discover(input) {
         return discoverTopics(input);
       },
       analyzeTopicDensity(input) {
-        return mcpParityClient.analyzeTopicDensity(input);
+        return functionSurfaceClient.analyzeTopicDensity(input);
       },
-      applyAutoBranching(input) {
-        return mcpParityClient.applyAutoBranching(input);
+      applyAutoBranching(input, idempotencyKey) {
+        return functionSurfaceClient.applyAutoBranching(input, idempotencyKey);
       },
-      seedBeliefLattice(input = {}) {
-        return mcpParityClient.seedBeliefLattice(input);
+      seedBeliefLattice(input = {}, idempotencyKey) {
+        return functionSurfaceClient.seedBeliefLattice(input, idempotencyKey);
       },
       getLatticeCoverage(input = {}) {
-        return mcpParityClient.getLatticeCoverage(input);
+        return functionSurfaceClient.getLatticeCoverage(input);
       },
       matchEntityType(input) {
         return ontologiesFacade.match(input).then(exposeGatewayData);
@@ -5701,7 +6542,7 @@ function createLucernClient(config = {}) {
     tasks: {
       create(input) {
         return tasksFacade.create({
-          topicId: requireTopicId(input),
+          topicId: resolveTopicId(input),
           title: input.title,
           description: input.description,
           taskType: input.taskType,
@@ -5834,7 +6675,7 @@ function createLucernClient(config = {}) {
           beliefA: args.beliefA,
           beliefB: args.beliefB,
           description: args.description,
-          topicId: requireTopicId(args),
+          topicId: resolveTopicId(args),
           severity: args.severity,
           defeatType: args.defeatType
         }).then(exposeGatewayData);
@@ -5880,38 +6721,50 @@ function createLucernClient(config = {}) {
       publishVersion(input) {
         return publishOntologyVersionCompat(input);
       },
+      publishOntologyVersion(input) {
+        return publishOntologyVersionCompat(input);
+      },
       deprecateVersion(input) {
         return deprecateOntologyVersionCompat(input);
       },
+      deprecateOntologyVersion(input) {
+        return deprecateOntologyVersionCompat(input);
+      },
       resolveEffective(input) {
         return resolveEffectiveOntologyCompat(input);
       },
+      resolveEffectiveOntology(input) {
+        return resolveEffectiveOntologyCompat(input);
+      },
       raw: ontologyClient
     },
     coordination: {
-      registerSession(input = {}) {
-        return mcpParityClient.registerSession(input);
+      registerSession(input = {}, idempotencyKey) {
+        return functionSurfaceClient.registerSession(input, idempotencyKey);
       },
-      heartbeatSession(input = {}) {
-        return mcpParityClient.heartbeatSession(input);
+      heartbeatSession(input = {}, idempotencyKey) {
+        return functionSurfaceClient.heartbeatSession(input, idempotencyKey);
       },
-      endSession(input = {}) {
-        return mcpParityClient.endSession(input);
+      endSession(input = {}, idempotencyKey) {
+        return functionSurfaceClient.endSession(input, idempotencyKey);
       },
       listActiveSessions(input = {}) {
-        return mcpParityClient.listActiveSessions(input);
+        return functionSurfaceClient.listActiveSessions(input);
       },
-      sendAgentMessage(input) {
-        return mcpParityClient.sendAgentMessage(input);
+      sendAgentMessage(input, idempotencyKey) {
+        return functionSurfaceClient.sendAgentMessage(input, idempotencyKey);
       },
-      broadcastMessage(input) {
-        return mcpParityClient.broadcastMessage(input);
+      broadcastMessage(input, idempotencyKey) {
+        return functionSurfaceClient.broadcastMessage(input, idempotencyKey);
       },
       getInbox(input = {}) {
-        return mcpParityClient.getAgentInbox(input);
+        return functionSurfaceClient.getAgentInbox(input);
       },
-      claimFiles(input) {
-        return mcpParityClient.claimFiles(input);
+      getAgentInbox(input = {}) {
+        return functionSurfaceClient.getAgentInbox(input);
+      },
+      claimFiles(input, idempotencyKey) {
+        return functionSurfaceClient.claimFiles(input, idempotencyKey);
       }
     },
     policy: {
@@ -5943,107 +6796,65 @@ function createLucernClient(config = {}) {
           principalId: typeof input.principalId === "string" ? input.principalId : void 0
         });
       },
-      manageWritePolicy(input) {
-        return mcpParityClient.manageWritePolicy(input);
+      manageWritePolicy(input, idempotencyKey) {
+        return functionSurfaceClient.manageWritePolicy(input, idempotencyKey);
       },
       raw: policyClient
     },
     observations: {
-      ingest(input) {
-        return mcpParityClient.ingestObservation(input);
+      ingest(input, idempotencyKey) {
+        return functionSurfaceClient.ingestObservation(input, idempotencyKey);
+      },
+      ingestObservation(input, idempotencyKey) {
+        return functionSurfaceClient.ingestObservation(input, idempotencyKey);
       },
       getContext(input) {
-        return mcpParityClient.getObservationContext(input);
+        return functionSurfaceClient.getObservationContext(input);
+      },
+      getObservationContext(input) {
+        return functionSurfaceClient.getObservationContext(input);
       }
     },
     coding: {
       getCodeContext(input) {
-        return mcpParityClient.getCodeContext(input);
+        return functionSurfaceClient.getCodeContext(input);
       },
       getChangeHistory(input) {
-        return mcpParityClient.getChangeHistory(input);
+        return functionSurfaceClient.getChangeHistory(input);
       },
-      recordAttempt(input) {
-        return mcpParityClient.recordAttempt(input);
+      recordAttempt(input, idempotencyKey) {
+        return functionSurfaceClient.recordAttempt(input, idempotencyKey);
       },
       getFailureLog(input) {
-        return mcpParityClient.getFailureLog(input);
+        return functionSurfaceClient.getFailureLog(input);
       }
     },
     contracts: {
       create(input) {
         return createContractCompat(input);
       },
+      createEpistemicContract(input) {
+        return createContractCompat(input);
+      },
       list(input = {}) {
         return listContractsCompat(input);
       },
       evaluate(input) {
         return evaluateContractCompat(input);
       },
+      evaluateContract(input) {
+        return evaluateContractCompat(input);
+      },
       getStatus(input) {
         return getContractStatusCompat(input);
+      },
+      getContractStatus(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: []
-          }
-        };
+        return functionSurfaceClient.generateSessionHandoff(input);
       }
     },
     tools: {
@@ -6108,6 +6919,8 @@ function createLucernClient(config = {}) {
     extensions: extensionNamespaces,
     raw: {
       beliefs: beliefsClient,
+      sources: sourcesClient,
+      evidence: evidenceClient,
       graph: graphClient,
       decisions: decisionsClient,
       workflow: workflowClient,
@@ -6117,7 +6930,7 @@ function createLucernClient(config = {}) {
       policy: policyClient,
       answers: answersClient,
       ontology: ontologyClient,
-      mcpParity: mcpParityClient,
+      functionSurface: functionSurfaceClient,
       packs: packsClient,
       reports: reportsClient,
       learning: learningClient,
@@ -6291,7 +7104,7 @@ function tokenHits(text, tokens) {
   }
   return hits;
 }
-function clamp01(value) {
+function clamp013(value) {
   if (!Number.isFinite(value)) {
     return 0;
   }
@@ -6304,13 +7117,13 @@ function recencyScore(updatedAt, referenceTimeMs = nowMs()) {
   const ageMs = Math.max(0, referenceTimeMs - updatedAt);
   const ageDays = ageMs / (1e3 * 60 * 60 * 24);
   const decay = 0.5 ** (ageDays / RECENCY_HALF_LIFE_DAYS);
-  return clamp01(decay);
+  return clamp013(decay);
 }
 function confidenceScore(confidence) {
   if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
     return 0.5;
   }
-  return clamp01(confidence);
+  return clamp013(confidence);
 }
 function priorityScore(priority) {
   const value = normalizeText(priority || "");
@@ -6378,7 +7191,7 @@ function computeBaselineScore(candidate, queryTokens) {
 }
 function computeWeightedScore(section, candidate, queryTokens, effectiveWeights, referenceTimeMs) {
   const weights = (effectiveWeights ?? RANKING_WEIGHTS)[section];
-  const queryComponent = queryTokens.length === 0 ? 0.4 : clamp01(tokenHits(candidate.text, queryTokens) / queryTokens.length);
+  const queryComponent = queryTokens.length === 0 ? 0.4 : clamp013(tokenHits(candidate.text, queryTokens) / queryTokens.length);
   const recencyComponent = recencyScore(
     candidate.updatedAt || candidate.createdAt || null,
     referenceTimeMs
@@ -6528,9 +7341,9 @@ function rankEntities(candidates, queryTokens, limit) {
   );
   const scored = candidates.map((candidate) => {
     const searchText = `${candidate.title} ${candidate.entityType} ${candidate.canonicalText}`;
-    const queryScore = queryTokens.length === 0 ? 0.4 : clamp01(tokenHits(searchText, queryTokens) / queryTokens.length);
+    const queryScore = queryTokens.length === 0 ? 0.4 : clamp013(tokenHits(searchText, queryTokens) / queryTokens.length);
     const totalConnections = candidate.connectedBeliefCount + candidate.connectedEvidenceCount;
-    const connectivityScore = clamp01(totalConnections / maxConnections);
+    const connectivityScore = clamp013(totalConnections / maxConnections);
     const score = queryScore * ENTITY_RANKING_WEIGHTS.query + connectivityScore * ENTITY_RANKING_WEIGHTS.connectivity;
     return { ...candidate, score };
   });
@@ -7515,11 +8328,17 @@ var FORK_REASONS = [
 ];
 var CONFIDENCE_TRIGGERS = [
   "evidence_added",
+  "evidence_removed",
   "contradiction_detected",
-  "merge_outcome",
+  "contradiction_resolved",
+  "agent_assessment",
   "worktree_outcome",
+  "worktree_completed",
   "manual",
-  "decay"
+  "decay",
+  "fusion",
+  "discount",
+  "deduction"
 ];
 var EPISTEMIC_EDGE_TYPES = [
   "supports",
@@ -7753,2979 +8572,18 @@ function buildDeprecatedBranchMetadata(args) {
   };
 }
 
-// src/contracts/mcp-tools.contract.ts
-var CREATE_BELIEF = {
-  name: "create_belief",
-  description: "Commit a new belief (knowledge unit) to the reasoning graph. Like `git commit` \u2014 creates an atomic, traceable knowledge object. The belief starts as unscored (draft). Score it with modulate_confidence to freeze the formulation.",
-  parameters: {
-    canonicalText: {
-      type: "string",
-      description: "The belief statement \u2014 what the agent holds to be true"
-    },
-    topicId: { type: "string", description: "Topic scope for the belief" },
-    beliefType: {
-      type: "string",
-      description: "Belief type (e.g., hypothesis, belief, principle, invariant, tenet, forecast). Validated against schemaEnumConfig."
-    },
-    metadata: {
-      type: "object",
-      description: "Optional extra metadata merged into the node (e.g., { codeAnchors: ['path/to/file.ts'] } for coding intelligence)"
-    }
-  },
-  required: ["canonicalText", "topicId"],
-  response: {
-    description: "The created canonical belief record",
-    fields: {
-      id: "string \u2014 canonical belief ID",
-      nodeId: "string \u2014 canonical belief ID",
-      beliefId: "string \u2014 canonical belief ID",
-      text: "string \u2014 canonical belief formulation",
-      topicId: "string",
-      status: "string \u2014 active | superseded | archived",
-      scoringState: "string \u2014 unscored | scored"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "belief",
-  tier: "showcase"
-};
-var GET_BELIEF = {
-  name: "get_belief",
-  description: "Read one belief by ID. Like `git show` \u2014 resolves the canonical belief payload for a single identifier.",
-  parameters: {
-    id: { type: "string", description: "Canonical belief ID" }
-  },
-  required: ["id"],
-  response: {
-    description: "The canonical belief record",
-    fields: {
-      id: "string \u2014 canonical belief ID",
-      nodeId: "string \u2014 canonical belief ID",
-      beliefId: "string \u2014 canonical belief ID",
-      text: "string \u2014 canonical belief formulation",
-      topicId: "string",
-      status: "string \u2014 active | superseded | archived",
-      scoringState: "string \u2014 unscored | scored"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "belief",
-  tier: "workhorse"
-};
-var REFINE_BELIEF = {
-  name: "refine_belief",
-  description: "Amend a draft belief in-place within an active worktree. Like `git commit --amend` \u2014 rewrites the last commit on a feature branch. Only valid before merge to main. Fails if the belief is already scored.",
-  parameters: {
-    nodeId: { type: "string", description: "The belief to refine" },
-    canonicalText: { type: "string", description: "Updated belief statement" },
-    rationale: { type: "string", description: "Why the refinement was made" }
-  },
-  required: ["nodeId", "canonicalText"],
-  response: {
-    description: "The updated belief node",
-    fields: {
-      nodeId: "string",
-      canonicalText: "string \u2014 updated text",
-      updatedAt: "number \u2014 timestamp"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "belief",
-  tier: "showcase"
-};
-var MODULATE_CONFIDENCE = {
-  name: "modulate_confidence",
-  description: "Record a confidence change for a belief. Like `git commit` to the credence log \u2014 an atomic, append-only write. Each modulation is a new entry in the history, not an overwrite. Scoring happens via merge; this tool records the individual data points. Triggers: evidence_added, contradiction_detected, merge_outcome, manual, decay.",
-  parameters: {
-    nodeId: { type: "string", description: "The belief to score" },
-    confidence: { type: "number", description: "Confidence level in [0, 1]" },
-    trigger: {
-      type: "string",
-      description: "What caused this confidence change",
-      enum: [
-        "evidence_added",
-        "contradiction_detected",
-        "merge_outcome",
-        "manual",
-        "decay"
-      ]
-    },
-    rationale: {
-      type: "string",
-      description: "Human-readable explanation of why confidence changed"
-    }
-  },
-  required: ["nodeId", "confidence", "trigger", "rationale"],
-  response: {
-    description: "Confidence modulation result",
-    fields: {
-      beliefId: "string \u2014 canonical belief ID",
-      nodeId: "string \u2014 canonical belief ID",
-      newConfidence: "number",
-      previousConfidence: "number",
-      trigger: "string",
-      requestId: "string \u2014 request identifier for the scheduled cascade",
-      propagationSummary: "object \u2014 bounded inline cascade summary with totalCandidateTargets, inlineTargets, and remainingTargetCount"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "belief",
-  tier: "showcase"
-};
-var FORK_BELIEF = {
-  name: "fork_belief",
-  description: "Branch off a scored belief to create a new version with a different formulation. Like `git fork` \u2014 the parent remains immutable with full history. The new belief gets a `supersedes` edge to the parent. Fork reasons: refinement, contradiction_response, scope_change, confidence_collapse, manual.",
-  parameters: {
-    nodeId: { type: "string", description: "The scored belief to fork from" },
-    newFormulation: {
-      type: "string",
-      description: "The evolved belief statement"
-    },
-    forkReason: {
-      type: "string",
-      description: "Why this fork was created",
-      enum: [
-        "refinement",
-        "contradiction_response",
-        "scope_change",
-        "confidence_collapse",
-        "manual"
-      ]
-    }
-  },
-  required: ["nodeId", "newFormulation", "forkReason"],
-  response: {
-    description: "The forked canonical belief record",
-    fields: {
-      id: "string \u2014 canonical child belief ID",
-      nodeId: "string \u2014 canonical child belief ID",
-      beliefId: "string \u2014 canonical child belief ID",
-      parentBeliefId: "string \u2014 canonical parent belief ID",
-      forkReason: "string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "belief",
-  tier: "showcase"
-};
-var ARCHIVE_BELIEF = {
-  name: "archive_belief",
-  description: "Soft-delete a belief by setting its status to archived. Like `git rm` \u2014 removed from the working tree but preserved in history. Beliefs are never truly deleted. Archived beliefs retain full lineage and confidence history.",
-  parameters: {
-    nodeId: { type: "string", description: "The belief to archive" },
-    rationale: {
-      type: "string",
-      description: "Why this belief is being archived"
-    }
-  },
-  required: ["nodeId"],
-  response: {
-    description: "Archived canonical belief record",
-    fields: {
-      beliefId: "string \u2014 canonical belief ID",
-      nodeId: "string \u2014 canonical belief ID",
-      previousStatus: "string | undefined",
-      newStatus: "string \u2014 'archived'",
-      status: "string \u2014 'archived'"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "belief",
-  tier: "showcase"
-};
-var CREATE_EPISTEMIC_CONTRACT = {
-  name: "create_epistemic_contract",
-  description: "Bind a machine-evaluable epistemic contract to a belief. Like `git add` for falsification rules \u2014 records the verification condition, modulation policy, and evaluation schedule that keep a belief accountable to reality.",
-  parameters: {
-    beliefNodeId: {
-      type: "string",
-      description: "The belief node to bind this contract to"
-    },
-    title: {
-      type: "string",
-      description: "Contract title"
-    },
-    description: {
-      type: "string",
-      description: "Optional contract description"
-    },
-    conditionType: {
-      type: "string",
-      description: "What kind of contract condition to evaluate",
-      enum: ["assertion", "temporal", "evidential", "threshold", "composite"]
-    },
-    direction: {
-      type: "string",
-      description: "Whether satisfying the condition confirms or falsifies",
-      enum: ["confirms", "falsifies"]
-    },
-    condition: {
-      type: "object",
-      description: "Condition payload: { expression, evaluator, evaluatorConfig? }"
-    },
-    deadline: {
-      type: "number",
-      description: "Optional Unix timestamp deadline for temporal contracts"
-    },
-    compositeOf: {
-      type: "array",
-      description: "Optional array of sub-contract IDs for composite contracts"
-    },
-    compositeOperator: {
-      type: "string",
-      description: "How composite sub-contracts should be combined",
-      enum: ["all", "any", "majority"]
-    },
-    modulation: {
-      type: "object",
-      description: "Asymmetric modulation rules for confirmed, disconfirmed, expired, and partial outcomes"
-    },
-    evaluationSchedule: {
-      type: "string",
-      description: "When this contract should be evaluated",
-      enum: ["on_demand", "on_evidence", "periodic", "event_driven"]
-    },
-    periodicIntervalMs: {
-      type: "number",
-      description: "Optional interval in milliseconds for periodic contracts"
-    }
-  },
-  required: [
-    "beliefNodeId",
-    "title",
-    "conditionType",
-    "direction",
-    "condition",
-    "modulation",
-    "evaluationSchedule"
-  ],
-  response: {
-    description: "The created epistemic contract binding",
-    fields: {
-      id: "string \u2014 storage record ID",
-      contractId: "string \u2014 contract identifier",
-      beliefId: "string \u2014 canonical belief ID",
-      status: "string \u2014 initial contract status",
-      title: "string \u2014 contract title"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "belief",
-  tier: "workhorse"
-};
-var ADD_EVIDENCE = {
-  name: "add_evidence",
-  description: "Commit evidence to the reasoning graph and attach it to a belief. Like `git add && git commit` \u2014 an atomic write that creates a traceable evidence object. Weight ranges from -1.0 (contradicts) to +1.0 (strongly supports). Evidence is always context-bound: tied to its source, the time it was captured, and the belief it informs.",
-  parameters: {
-    canonicalText: { type: "string", description: "The evidence statement" },
-    topicId: { type: "string", description: "Topic scope" },
-    sourceUrl: { type: "string", description: "URL of the source material" },
-    targetNodeId: {
-      type: "string",
-      description: "The belief this evidence bears on"
-    },
-    weight: {
-      type: "number",
-      description: "Support weight: -1.0 (contradicts) to +1.0 (supports)"
-    },
-    reasoning: {
-      type: "string",
-      description: "Why this evidence is relevant to the target belief"
-    },
-    title: {
-      type: "string",
-      description: "Optional short title for the evidence node"
-    },
-    content: {
-      type: "string",
-      description: "Optional long-form content (separate from canonicalText summary)"
-    },
-    contentType: {
-      type: "string",
-      description: "Content MIME type or format hint (e.g., 'text/markdown', 'code')"
-    },
-    metadata: {
-      type: "object",
-      description: "Optional extra metadata merged into the node (e.g., { codeAnchors: ['path/to/file.ts'], failedApproach: true } for coding intelligence)"
-    }
-  },
-  required: ["canonicalText", "topicId", "targetNodeId"],
-  response: {
-    description: "The created evidence node and its edge",
-    fields: {
-      nodeId: "string \u2014 evidence node ID",
-      edgeId: "string \u2014 edge to target belief"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "evidence",
-  tier: "showcase"
-};
-var FLAG_CONTRADICTION = {
-  name: "flag_contradiction",
-  description: "Flag a contradiction between two beliefs. Contradictions are first-class objects with their own lifecycle \u2014 they may remain permanently unresolved. Like a merge conflict that is allowed to persist. Contradictions can trigger structural changes: forking, confidence collapse, or decision blocking. Resolution is NEVER automatic \u2014 always surfaces for human review.",
-  parameters: {
-    beliefA: {
-      type: "string",
-      description: "First belief in the contradiction"
-    },
-    beliefB: {
-      type: "string",
-      description: "Second belief in the contradiction"
-    },
-    description: { type: "string", description: "What the tension is about" },
-    severity: {
-      type: "string",
-      description: "How serious the contradiction is",
-      enum: ["low", "medium", "high", "critical"]
-    },
-    topicId: { type: "string", description: "Topic scope" },
-    defeatType: {
-      type: "string",
-      description: "Pollock defeat classification: rebuts (direct contradiction), undercuts (attacks the inferential link), undermines (attacks a premise)",
-      enum: ["rebuts", "undercuts", "undermines"]
-    }
-  },
-  required: ["beliefA", "beliefB", "description", "topicId"],
-  response: {
-    description: "The created contradiction object",
-    fields: {
-      contradictionId: "string",
-      status: "string \u2014 'unresolved'",
-      beliefA: "string",
-      beliefB: "string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "belief",
-  tier: "showcase"
-};
-var ADD_WORKTREE = {
-  name: "add_worktree",
-  description: "Check out a branch into an active worktree for investigation. Like `git worktree add <branch>` \u2014 creates independent working state on a thematic branch. Beliefs committed within the worktree can be freely amended (draft code on a feature branch). When investigation is complete, `merge` integrates findings into main.",
-  parameters: {
-    title: { type: "string", description: "Worktree name/objective" },
-    topicId: { type: "string", description: "Topic scope" },
-    branchId: {
-      type: "string",
-      description: "The branch this worktree investigates"
-    },
-    objective: {
-      type: "string",
-      description: "Plain-text reasoning objective to auto-shape into a hypothesis, questions, tasks, and dependencies"
-    },
-    hypothesis: {
-      type: "string",
-      description: "The testable claim this worktree investigates"
-    },
-    beliefIds: {
-      type: "array",
-      description: "Beliefs to test in this worktree"
-    },
-    autoShape: {
-      type: "boolean",
-      description: "Whether to invoke inquiry auto-shaping during worktree creation"
-    },
-    domainPackId: {
-      type: "string",
-      description: "Optional domain pack whose shaping hooks should influence generated questions and tasks"
-    },
-    executionOrder: {
-      type: "number",
-      description: "Global execution order for this worktree"
-    },
-    dependsOn: {
-      type: "array",
-      description: "Worktree IDs that must complete before this one can activate"
-    },
-    blocks: {
-      type: "array",
-      description: "Worktree IDs blocked by this worktree"
-    },
-    gate: {
-      type: "string",
-      description: "Exit gate name for this worktree"
-    }
-  },
-  required: ["title", "topicId"],
-  response: {
-    description: "The created worktree",
-    fields: {
-      worktreeId: "string",
-      branchId: "string | null",
-      status: "string \u2014 usually 'planning' or 'active'",
-      title: "string",
-      hypothesis: "string | null",
-      questionCount: "number",
-      taskCount: "number",
-      autoShapeApplied: "boolean",
-      frameworkSuggestions: "array",
-      dependencySuggestions: "array"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "worktree",
-  tier: "showcase"
-};
-var MERGE = {
-  name: "merge",
-  description: "Merge a worktree's findings into the stable knowledge base (main). Like `git merge` to main \u2014 formulations freeze, confidence is recorded, findings are integrated. Each belief gets a confidence score and rationale. After merge, beliefs can only evolve via fork. Low-confidence beliefs may need forking.",
-  parameters: {
-    worktreeId: { type: "string", description: "The worktree to merge" },
-    outcomes: {
-      type: "array",
-      description: "Scoring outcomes for each belief: { beliefId, confidence, rationale }"
-    },
-    summary: { type: "string", description: "Overall findings summary" }
-  },
-  required: ["worktreeId", "outcomes"],
-  response: {
-    description: "Merge result",
-    fields: {
-      worktreeId: "string",
-      status: "string \u2014 'merged'",
-      beliefsScored: "number"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "worktree",
-  tier: "showcase"
-};
-var QUERY_LINEAGE = {
-  name: "query_lineage",
-  description: "Trace a belief's full ancestry \u2014 every fork, score, and confidence modulation. Like `git log --graph`. Returns the complete evolution chain showing how understanding developed over time. Lineage is permanent and can never be erased (Invariant #3).",
-  parameters: {
-    nodeId: { type: "string", description: "Starting node to trace from" },
-    depth: {
-      type: "number",
-      description: "How many generations to traverse (default: 5)"
-    }
-  },
-  required: ["nodeId"],
-  response: {
-    description: "Canonical lineage result",
-    fields: {
-      beliefId: "string \u2014 canonical belief ID",
-      lineage: "array \u2014 ancestry entries with beliefId, nodeId, formulation, forkReason, and createdAt"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "belief",
-  tier: "workhorse"
-};
-var GET_CONFIDENCE_HISTORY = {
-  name: "get_confidence_history",
-  description: "Get the full confidence history for a belief. Each entry records the confidence level, trigger, rationale, and actor. Like `git log` for a single metric \u2014 append-only, never overwritten.",
-  parameters: {
-    nodeId: { type: "string", description: "The belief to get history for" }
-  },
-  required: ["nodeId"],
-  response: {
-    description: "Confidence history entries",
-    fields: {
-      beliefId: "string \u2014 canonical belief ID",
-      entries: "array \u2014 { confidence, trigger, rationale, timestamp, userId }",
-      nextCursor: "string | null"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "belief",
-  tier: "workhorse"
-};
-var GET_AUDIT_TRAIL = {
-  name: "get_audit_trail",
-  description: "Get the full audit trail for a node \u2014 every mutation, who made it, when, and why. Like `git blame` for knowledge. All state transitions are explicit, attributable, and permanently queryable. No silent changes are possible (Invariant #14).",
-  parameters: {
-    nodeId: { type: "string", description: "The node to audit" },
-    limit: {
-      type: "number",
-      description: "Maximum entries to return (default: 50)"
-    }
-  },
-  required: ["nodeId"],
-  response: {
-    description: "Audit trail entries",
-    fields: {
-      entries: "array \u2014 { action, actor, timestamp, before, after, rationale }"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var TRAVERSE_GRAPH = {
-  name: "traverse_graph",
-  description: "Walk the reasoning graph from a starting node. Like `git log --graph` \u2014 traverses connected lineage across nodes and edges. Traversal follows epistemic layers: L4 (judgments) \u2192 L3 (beliefs, questions) \u2192 L2 (evidence) \u2192 L1 (sources). Never skips layers. Use direction 'up' to trace what a piece of evidence supports, 'down' to trace what supports a judgment.",
-  parameters: {
-    startNode: { type: "string", description: "Node to start traversal from" },
-    direction: {
-      type: "string",
-      description: "Traversal direction",
-      enum: ["up", "down", "both"]
-    },
-    maxDepth: {
-      type: "number",
-      description: "Maximum traversal depth (default: 3)"
-    }
-  },
-  required: ["startNode"],
-  response: {
-    description: "Subgraph of traversed nodes and edges",
-    fields: {
-      nodes: "array \u2014 traversed nodes",
-      edges: "array \u2014 traversed edges",
-      depth: "number"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var GET_GRAPH_NEIGHBORHOOD = {
-  name: "get_graph_neighborhood",
-  description: "Retrieve the local neighborhood around one or more graph nodes. Like `git log --graph --boundary` for a focused reasoning window. Returns the canonical neighborhood payload shared by HTTP and SDK graph surfaces.",
-  parameters: {
-    globalId: {
-      type: "string",
-      description: "Single root node global identifier."
-    },
-    globalIds: {
-      type: "array",
-      description: "Optional list of root node global identifiers."
-    },
-    maxDepth: {
-      type: "number",
-      description: "Maximum traversal depth (default: 2)."
-    }
-  },
-  required: [],
-  response: {
-    description: "Canonical graph neighborhood payload",
-    fields: {
-      nodes: "array \u2014 graph nodes in the returned neighborhood",
-      edges: "array \u2014 graph edges in the returned neighborhood",
-      depth: "number \u2014 deepest traversed node depth"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var TRACE_ENTITY_IMPACT = {
-  name: "trace_entity_impact",
-  description: "Returns code-grounded beliefs, contracts, migration states, and failed attempts anchored to a specific file or function path. Like `git log -- <path>` \u2014 filters the knowledge graph to nodes anchored to a file path via metadata.codeAnchors. Results are separated by coding belief type: decisions, contracts, migrations, patterns, deprecations, and failures.",
-  parameters: {
-    nodeId: {
-      type: "string",
-      description: "Entity node ID to trace impact from"
-    }
-  },
-  required: ["nodeId"],
-  response: {
-    description: "Entity impact trace: direct beliefs, evidence, and indirect belief reach",
-    fields: {
-      entityNodeId: "string \u2014 the traced entity",
-      entityType: "string \u2014 nodeType of the entity",
-      directBeliefConnections: "array \u2014 beliefs directly connected via bridge edges",
-      evidenceConnections: "array \u2014 evidence referencing this entity",
-      indirectBeliefConnections: "array \u2014 beliefs reached through evidence",
-      totalBeliefReach: "number \u2014 total unique beliefs impacted"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var SEARCH_BELIEFS = {
-  name: "search_beliefs",
-  description: "Search for beliefs in the reasoning graph. Like `git grep` \u2014 finds relevant beliefs across the full history and active state. Supports semantic search, filtering by status (unscored, scored, archived), confidence thresholds, and topic scope. Returns beliefs with their current confidence, lineage depth, and contradiction count.",
-  parameters: {
-    query: { type: "string", description: "Semantic search query" },
-    status: {
-      type: "string",
-      description: "Filter by belief status",
-      enum: ["unscored", "scored", "archived"]
-    },
-    minConfidence: {
-      type: "number",
-      description: "Minimum confidence threshold (0-1)"
-    },
-    topicId: { type: "string", description: "Filter by topic" },
-    limit: { type: "number", description: "Maximum results (default: 10)" }
-  },
-  required: ["query"],
-  response: {
-    description: "Matching beliefs with metadata",
-    fields: {
-      results: "array \u2014 { nodeId, canonicalText, confidence, status, contradictionCount }"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "belief",
-  tier: "workhorse"
-};
-var SEARCH_RESOURCES = {
-  name: "search_resources",
-  description: "Search beliefs, evidence, and questions in one cross-resource call. Like `git grep` across the reasoning stack \u2014 returns one ranked payload with grouped hits by resource type.",
-  parameters: {
-    q: { type: "string", description: "Search query" },
-    topicId: { type: "string", description: "Topic scope" },
-    types: {
-      type: "array",
-      description: "Optional resource filters: belief, evidence, question"
-    },
-    status: {
-      type: "string",
-      description: "Optional belief/question status filter"
-    },
-    minConfidence: {
-      type: "number",
-      description: "Optional minimum belief confidence threshold"
-    },
-    limit: { type: "number", description: "Maximum results (default: 25)" },
-    cursor: { type: "string", description: "Optional pagination cursor" }
-  },
-  required: ["q", "topicId"],
-  response: {
-    description: "Canonical cross-resource search payload",
-    fields: {
-      q: "string \u2014 echoed query text",
-      topicId: "string \u2014 canonical topic scope",
-      types: "array \u2014 the resource types included in the search",
-      results: "array \u2014 ranked mixed resource hits",
-      beliefs: "array \u2014 grouped belief hits",
-      evidence: "array \u2014 grouped evidence hits",
-      questions: "array \u2014 grouped question hits"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var FIND_CONTRADICTIONS = {
-  name: "find_contradictions",
-  description: "Find contradictions in the reasoning graph \u2014 beliefs that are in tension with each other. Like a merge conflict in `git` \u2014 surfaces incompatible states that require explicit resolution. Contradictions are first-class objects that may remain permanently unresolved. They can block judgments, trigger forks, or collapse confidence. Filter by project, status (unresolved, resolved, accepted), and severity.",
-  parameters: {
-    topicId: { type: "string", description: "Filter by topic" },
-    nodeId: {
-      type: "string",
-      description: "Find contradictions involving a specific belief"
-    },
-    status: {
-      type: "string",
-      description: "Filter by status",
-      enum: ["unresolved", "resolved", "accepted"]
-    }
-  },
-  required: [],
-  response: {
-    description: "Contradiction objects",
-    fields: {
-      contradictions: "array \u2014 { beliefA, beliefB, description, severity, status, defeatType }"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "belief",
-  tier: "showcase"
-};
-var CREATE_EDGE = {
-  name: "create_edge",
-  description: "Commit a typed relationship between two nodes in the reasoning graph. Like `git commit` \u2014 an atomic write that declares a dependency between nodes. The engine enforces layer transition rules \u2014 for example, L1 \u2192 L3 direct edges are forbidden (must go through L2).",
-  parameters: {
-    sourceId: {
-      type: "string",
-      description: "Source node of the relationship"
-    },
-    targetId: {
-      type: "string",
-      description: "Target node of the relationship"
-    },
-    edgeType: {
-      type: "string",
-      description: "Relationship type (informs, tests, depends_on, supersedes, etc.)"
-    },
-    weight: {
-      type: "number",
-      description: "Edge weight: -1.0 to +1.0 for informs edges, 0-1 for structural"
-    },
-    reasoning: { type: "string", description: "Why this relationship exists" },
-    reasoningMethod: {
-      type: "string",
-      description: "How this was determined",
-      enum: ["deductive", "inductive", "abductive", "analogical", "empirical"]
-    }
-  },
-  required: ["sourceId", "targetId", "edgeType"],
-  response: {
-    description: "The created edge",
-    fields: {
-      globalId: "string \u2014 edge identifier",
-      edgeType: "string",
-      fromLayer: "string",
-      toLayer: "string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "edge",
-  tier: "showcase"
-};
-var RECORD_JUDGMENT = {
-  name: "record_judgment",
-  description: "Record a judgment \u2014 an irreversible commitment based on the current epistemic state. Like a `git tag` marking a release. A judgment synthesizes beliefs, evidence, and uncertainties into a determination. Once issued, a judgment is evaluated against the epistemic state that existed when it was made (knowledge horizon evaluation, Invariant #10).",
-  parameters: {
-    title: { type: "string", description: "Short judgment statement" },
-    rationale: {
-      type: "string",
-      description: "Full reasoning behind the judgment"
-    },
-    topicId: { type: "string", description: "Topic scope" },
-    beliefIds: {
-      type: "array",
-      description: "Beliefs that warrant this judgment"
-    },
-    confidence: {
-      type: "number",
-      description: "Confidence in the judgment (0-1)"
-    }
-  },
-  required: ["title", "rationale", "topicId"],
-  response: {
-    description: "The recorded judgment",
-    fields: {
-      judgmentId: "string",
-      title: "string",
-      status: "string \u2014 'issued'"
-    }
-  },
-  ownerModule: "decision-state",
-  ontologyPrimitive: "judgment",
-  tier: "showcase"
-};
-var CREATE_LENS = {
-  name: "create_lens",
-  description: "Create a reusable lens that overlays a workspace topic with a specific analytical perspective. Like `git branch <name>` for operational scaffolding \u2014 a lens persists across worktrees and carries prompts, workflows, and task templates. Multiple topics in the same workspace can reuse the same lens.",
-  parameters: {
-    name: {
-      type: "string",
-      description: "Lens name (e.g., 'market dynamics', 'team quality')"
-    },
-    workspaceId: {
-      type: "string",
-      description: "Workspace scope for the lens. Required unless topicId resolves to a workspace-scoped topic."
-    },
-    topicId: {
-      type: "string",
-      description: "Optional originating topic scope. Lenses remain reusable across topics even when this is set."
-    },
-    description: {
-      type: "string",
-      description: "What this lens is designed to investigate or monitor"
-    },
-    perspectiveType: {
-      type: "string",
-      description: "Perspective type for the lens. Validated against schemaEnumConfig category 'lens_perspective_type'.",
-      enum: [...LENS_PERSPECTIVE_TYPES]
-    },
-    promptTemplates: {
-      type: "array",
-      description: "Langfuse prompt references used when operating through this lens"
-    },
-    workflowTemplates: {
-      type: "array",
-      description: "Guided workflow templates for lens-driven investigations"
-    },
-    taskTemplates: {
-      type: "array",
-      description: "Default task templates instantiated when the lens is applied"
-    },
-    filterCriteria: {
-      type: "object",
-      description: "Belief/evidence filtering rules applied by the lens"
-    }
-  },
-  required: ["name", "perspectiveType"],
-  response: {
-    description: "The created lens",
-    fields: {
-      lensId: "string",
-      name: "string",
-      workspaceId: "string",
-      status: "string \u2014 'active'"
-    }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "lens",
-  tier: "showcase"
-};
-var LIST_LENSES = {
-  name: "list_lenses",
-  description: "List reusable lenses for a workspace, optionally scored by whether they are active on a topic. Like `git branch --list` \u2014 shows the available named frames you can activate. When topicId is provided, the response can indicate which lenses are already applied there.",
-  parameters: {
-    workspaceId: {
-      type: "string",
-      description: "Workspace scope to list lenses from"
-    },
-    topicId: {
-      type: "string",
-      description: "Optional topic scope used to derive workspace and annotate applied lenses"
-    },
-    status: {
-      type: "string",
-      description: "Filter by lens lifecycle status",
-      enum: ["draft", "active", "archived"]
-    },
-    perspectiveType: {
-      type: "string",
-      description: "Filter by perspective type",
-      enum: [...LENS_PERSPECTIVE_TYPES]
-    }
-  },
-  required: [],
-  response: {
-    description: "Available lenses",
-    fields: {
-      lenses: "array \u2014 each item includes lensId, name, workspaceId, perspectiveType, status, and optional isAppliedToTopic"
-    }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "lens",
-  tier: "workhorse"
-};
-var APPLY_LENS_TO_TOPIC = {
-  name: "apply_lens_to_topic",
-  description: "Apply a lens to a topic so it becomes an active perspective overlay. Like `git checkout <branch>` for a reusable frame \u2014 the topic keeps its knowledge, but the active lens shapes guidance and retrieval. Multiple active lenses can coexist on the same topic.",
-  parameters: {
-    lensId: { type: "string", description: "Lens to activate on the topic" },
-    topicId: { type: "string", description: "Topic that should receive the lens" }
-  },
-  required: ["lensId", "topicId"],
-  response: {
-    description: "Lens activation result",
-    fields: {
-      bindingId: "string",
-      lensId: "string",
-      topicId: "string",
-      status: "string \u2014 'active'"
-    }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "lens",
-  tier: "workhorse"
-};
-var REMOVE_LENS_FROM_TOPIC = {
-  name: "remove_lens_from_topic",
-  description: "Remove an active lens overlay from a topic. Like `git switch` away from a frame \u2014 the topic remains, but the lens stops shaping the investigation context. Historical binding state is preserved for auditability.",
-  parameters: {
-    lensId: { type: "string", description: "Lens to remove from the topic" },
-    topicId: { type: "string", description: "Topic that currently has the lens applied" }
-  },
-  required: ["lensId", "topicId"],
-  response: {
-    description: "Lens removal result",
-    fields: {
-      bindingId: "string",
-      lensId: "string",
-      topicId: "string",
-      status: "string \u2014 'removed'"
-    }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "lens",
-  tier: "workhorse"
-};
-var PUSH = {
-  name: "push",
-  description: "Push scored beliefs from a merged worktree to other contexts. Like `git push` \u2014 makes local findings available on the remote. Only merged beliefs can be pushed. Publication makes findings visible to other projects, teams, or external consumers.",
-  parameters: {
-    worktreeId: {
-      type: "string",
-      description: "The merged worktree whose findings to push"
-    },
-    targetContext: {
-      type: "string",
-      description: "Where to push (e.g., 'portfolio', 'ic_review', 'external')"
-    },
-    beliefIds: {
-      type: "array",
-      description: "Optional subset of beliefs to push (default: all scored)"
-    }
-  },
-  required: ["worktreeId", "targetContext"],
-  response: {
-    description: "Push result",
-    fields: {
-      pushedCount: "number",
-      targetContext: "string",
-      pushedAt: "number"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "worktree",
-  tier: "workhorse"
-};
-var OPEN_PULL_REQUEST = {
-  name: "open_pull_request",
-  description: "Open a pull request for peer review before merging a worktree. Like opening a `git pull request` \u2014 the worktree's findings are ready but await approval before merge. Reviewers can approve, request changes, or block the merge. This is the gate between draft work and scored knowledge.",
-  parameters: {
-    worktreeId: {
-      type: "string",
-      description: "The worktree to submit for review"
-    },
-    reviewers: {
-      type: "array",
-      description: "User IDs of requested reviewers"
-    },
-    summary: {
-      type: "string",
-      description: "Summary of findings and why they're ready for merge"
-    }
-  },
-  required: ["worktreeId", "summary"],
-  response: {
-    description: "The pull request",
-    fields: {
-      pullRequestId: "string",
-      worktreeId: "string",
-      status: "string \u2014 'pending_review'"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "worktree",
-  tier: "showcase"
-};
-var BISECT_CONFIDENCE = {
-  name: "bisect_confidence",
-  description: "Find when a belief's confidence diverged from reality. Like `git bisect` \u2014 binary search through the credence history to find the inflection point. Given a belief that is now known to be wrong (or right), traces back through confidence modulations to identify which evidence or event caused the divergence.",
-  parameters: {
-    nodeId: { type: "string", description: "The belief to bisect" },
-    expectedDirection: {
-      type: "string",
-      description: "Was confidence too high or too low?",
-      enum: ["overconfident", "underconfident"]
-    },
-    timeRange: {
-      type: "object",
-      description: "Optional time range to search within: { start: number, end: number }"
-    }
-  },
-  required: ["nodeId", "expectedDirection"],
-  response: {
-    description: "The inflection point in confidence history",
-    fields: {
-      beliefId: "string \u2014 canonical belief ID",
-      expectedDirection: "string \u2014 overconfident | underconfident",
-      inflectionEntry: "object \u2014 the confidence modulation where divergence began",
-      triggerEvent: "string | null \u2014 what caused the divergence",
-      confidenceBefore: "number | null",
-      confidenceAfter: "number | null",
-      totalEntries: "number",
-      inflectionIndex: "number | null"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "belief",
-  tier: "showcase"
-};
-var DETECT_CONFIRMATION_BIAS = {
-  name: "detect_confirmation_bias",
-  description: "Detect confirmation bias in the evidence graph. Like `git diff --stat` for reasoning \u2014 analyzes the ratio of supporting vs challenging evidence per belief and flags beliefs where the evidence is suspiciously one-sided. Returns risk classification (critical/high/moderate/healthy).",
-  parameters: {
-    topicId: { type: "string", description: "Topic to analyze" },
-    threshold: {
-      type: "number",
-      description: "Bias threshold (0-1, default 0.7)"
-    }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Beliefs with bias scores, risk levels, and evidence counts",
-    fields: {
-      beliefs: "array \u2014 { nodeId, biasScore, riskLevel, supportingCount, challengingCount }"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "graph",
-  tier: "showcase"
-};
-var GET_GRAPH_STRUCTURE_ANALYSIS = {
-  name: "get_graph_structure_analysis",
-  description: "Run comprehensive structural analysis on the knowledge graph. Like `git fsck` combined with PageRank \u2014 runs 14 algorithmic detectors including PageRank centrality, Louvain community detection, Tarjan SCC, Fiedler vector spectral analysis, Bayesian surprise, and overconfidence detection.",
-  parameters: {
-    topicId: { type: "string", description: "Topic to analyze" }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Structural analysis with detector results and recommendations",
-    fields: {
-      topicId: "string \u2014 canonical topic scope",
-      metric: "string \u2014 analysis metric identifier",
-      payload: "object \u2014 detector results, recommendations, graph metrics"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "graph",
-  tier: "showcase"
-};
-var GET_FALSIFICATION_QUESTIONS = {
-  name: "get_falsification_questions",
-  description: "Generate Popperian falsification questions for beliefs. Like `git test` \u2014 identifies the questions most likely to disprove current beliefs. Karl Popper as a tool: surfaces what would need to be true to invalidate each belief.",
-  parameters: {
-    topicId: { type: "string", description: "Topic to analyze" },
-    beliefIds: { type: "array", description: "Specific beliefs to target" }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Questions with falsification potential scores and target beliefs",
-    fields: {
-      questions: "array \u2014 { questionText, falsificationPotential, targetBeliefId, targetBeliefText }"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "question",
-  tier: "showcase"
-};
-var SEARCH_SOURCES = {
-  name: "search_sources",
-  description: "Search and ingest external sources into the knowledge graph. Like `git fetch` \u2014 pulls information from external sources (web, documents, APIs) and stages it for evidence creation. Does not commit \u2014 you decide what becomes evidence.",
-  parameters: {
-    query: { type: "string", description: "Search query" },
-    sources: {
-      type: "array",
-      description: "Source types to search: web, news, academic"
-    }
-  },
-  required: ["query"],
-  response: {
-    description: "Results with source metadata, relevance scores, and suggested evidence",
-    fields: {
-      results: "array \u2014 { title, url, snippet, relevanceScore, suggestedEvidence }"
-    }
-  },
-  ownerModule: "research-engine",
-  ontologyPrimitive: "source",
-  tier: "showcase"
-};
-var EXECUTE_DEEP_RESEARCH = {
-  name: "execute_deep_research",
-  description: "Execute multi-source deep research on a topic. Like `git submodule update --recursive` \u2014 launches a comprehensive research agent that searches multiple sources, synthesizes findings, and produces a structured report. Auto-links results to relevant questions and beliefs.",
-  parameters: {
-    query: { type: "string", description: "Research question or topic" },
-    topicId: { type: "string", description: "Topic scope" },
-    depth: {
-      type: "string",
-      description: "Research depth: quick, standard, deep",
-      enum: ["quick", "standard", "deep"]
-    }
-  },
-  required: ["query", "topicId"],
-  response: {
-    description: "Report with findings, sources, auto-linked evidence and questions",
-    fields: {
-      report: "object \u2014 { summary, findings, sources, linkedEvidence, linkedQuestions }"
-    }
-  },
-  ownerModule: "research-engine",
-  ontologyPrimitive: "source",
-  tier: "showcase"
-};
-var SEARCH_EVIDENCE = {
-  name: "search_evidence",
-  description: "Search for evidence across the reasoning graph. Like `git grep` \u2014 returns the evidence records that best match a textual query. Results share the same canonical semantics as the HTTP and SDK evidence search surface.",
-  parameters: {
-    q: { type: "string", description: "Search text" },
-    topicId: { type: "string", description: "Topic scope filter" },
-    targetId: {
-      type: "string",
-      description: "Optional belief or question identifier to scope the search"
-    },
-    limit: { type: "number", description: "Max results" },
-    cursor: { type: "string", description: "Pagination cursor" }
-  },
-  required: ["q"],
-  response: {
-    description: "Canonical evidence search results page",
-    fields: {
-      results: "array \u2014 { evidenceId, nodeId, globalId?, text, source?, kind?, relevanceScore }",
-      nextCursor: "string | null"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "evidence",
-  tier: "workhorse"
-};
-var CREATE_EVIDENCE = {
-  name: "create_evidence",
-  description: "Commit evidence to the reasoning graph. Like `git commit` \u2014 creates a traceable evidence record with canonical public IDs. Optionally links the evidence to a belief or question in the same operation.",
-  parameters: {
-    topicId: { type: "string", description: "Topic scope" },
-    text: { type: "string", description: "Canonical evidence text" },
-    source: { type: "string", description: "Source URL or source label" },
-    targetId: {
-      type: "string",
-      description: "Optional belief or question identifier to link immediately"
-    },
-    weight: {
-      type: "number",
-      description: "Support weight: -1.0 (contradicts) to +1.0 (supports)"
-    },
-    metadata: {
-      type: "object",
-      description: "Optional metadata merged into the canonical evidence node"
-    },
-    title: { type: "string", description: "Optional short title" },
-    content: { type: "string", description: "Optional long-form content" },
-    contentType: {
-      type: "string",
-      description: "Optional content format or MIME hint"
-    },
-    kind: { type: "string", description: "Optional evidence kind" }
-  },
-  required: ["topicId", "text"],
-  response: {
-    description: "The created canonical evidence record",
-    fields: {
-      id: "string \u2014 canonical evidence ID",
-      nodeId: "string \u2014 canonical evidence ID",
-      evidenceId: "string \u2014 canonical evidence ID",
-      text: "string",
-      topicId: "string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "evidence",
-  tier: "workhorse"
-};
-var GET_EVIDENCE = {
-  name: "get_evidence",
-  description: "Read one evidence record by ID. Like `git show` \u2014 resolves the canonical evidence payload for a single identifier.",
-  parameters: {
-    id: { type: "string", description: "Canonical evidence ID" }
-  },
-  required: ["id"],
-  response: {
-    description: "The canonical evidence record",
-    fields: {
-      id: "string \u2014 canonical evidence ID",
-      nodeId: "string \u2014 canonical evidence ID",
-      evidenceId: "string \u2014 canonical evidence ID",
-      text: "string",
-      topicId: "string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "evidence",
-  tier: "workhorse"
-};
-var LIST_EVIDENCE = {
-  name: "list_evidence",
-  description: "List evidence records within a topic or linked to a target. Like `git log -- path` \u2014 returns the canonical evidence page for a topic, belief, or question scope.",
-  parameters: {
-    topicId: { type: "string", description: "Topic scope filter" },
-    targetId: {
-      type: "string",
-      description: "Optional belief or question identifier to scope by linkage"
-    },
-    limit: { type: "number", description: "Max results" },
-    cursor: { type: "string", description: "Pagination cursor" }
-  },
-  required: [],
-  response: {
-    description: "Canonical evidence page",
-    fields: {
-      evidence: "array \u2014 canonical evidence records",
-      nextCursor: "string | null"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "evidence",
-  tier: "workhorse"
-};
-var LINK_EVIDENCE = {
-  name: "link_evidence",
-  description: "Link evidence to a belief or question. Like `git notes add` \u2014 attaches a supporting or contradicting edge without rewriting the evidence itself.",
-  parameters: {
-    evidenceId: { type: "string", description: "Canonical evidence ID" },
-    targetId: {
-      type: "string",
-      description: "Canonical belief or question ID"
-    },
-    weight: {
-      type: "number",
-      description: "Support weight: -1.0 (contradicts) to +1.0 (supports)"
-    },
-    rationale: { type: "string", description: "Why this link exists" }
-  },
-  required: ["evidenceId", "targetId"],
-  response: {
-    description: "The created canonical evidence edge summary",
-    fields: {
-      edgeId: "string",
-      evidenceId: "string",
-      targetId: "string",
-      targetType: "string \u2014 belief | question",
-      weight: "number"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "edge",
-  tier: "workhorse"
-};
-var LINK_EVIDENCE_TO_BELIEF = {
-  name: "link_evidence_to_belief",
-  description: "Link evidence to a belief with a support weight. Like `git add` \u2014 stages evidence in support of (or against) a belief. The weight ranges from -1.0 (strongly contradicts) to +1.0 (strongly supports).",
-  parameters: {
-    evidenceId: { type: "string", description: "The evidence node ID" },
-    beliefId: { type: "string", description: "The belief node ID" },
-    weight: {
-      type: "number",
-      description: "Support weight: -1.0 (contradicts) to +1.0 (supports)"
-    },
-    rationale: { type: "string", description: "Why this evidence is relevant" }
-  },
-  required: ["evidenceId", "beliefId", "weight"],
-  response: {
-    description: "The created edge linking evidence to belief",
-    fields: {
-      edgeId: "string",
-      evidenceId: "string",
-      beliefId: "string",
-      weight: "number"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "edge",
-  tier: "workhorse"
-};
-var CREATE_QUESTION = {
-  name: "create_question",
-  description: "Commit an investigation question to the reasoning graph. Like `git issue` \u2014 creates a traceable question that drives research and evidence collection. Questions test beliefs and guide worktree investigation.",
-  parameters: {
-    text: { type: "string", description: "The question text" },
-    topicId: { type: "string", description: "Topic scope" },
-    priority: {
-      type: "string",
-      description: "Priority: urgent, high, medium, low",
-      enum: ["urgent", "high", "medium", "low"]
-    },
-    linkedBeliefId: {
-      type: "string",
-      description: "Belief this question tests"
-    },
-    metadata: {
-      type: "object",
-      description: "Optional metadata merged into the question record"
-    }
-  },
-  required: ["text", "topicId"],
-  response: {
-    description: "The created canonical question record",
-    fields: {
-      id: "string \u2014 canonical question ID",
-      nodeId: "string \u2014 canonical question ID",
-      questionId: "string \u2014 canonical question ID",
-      text: "string",
-      status: "string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "question",
-  tier: "workhorse"
-};
-var GET_QUESTION = {
-  name: "get_question",
-  description: "Read one question by ID. Like `git show` \u2014 resolves the canonical question payload for a single identifier.",
-  parameters: {
-    id: { type: "string", description: "Canonical question ID" }
-  },
-  required: ["id"],
-  response: {
-    description: "The canonical question record",
-    fields: {
-      id: "string \u2014 canonical question ID",
-      nodeId: "string \u2014 canonical question ID",
-      questionId: "string \u2014 canonical question ID",
-      text: "string",
-      status: "string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "question",
-  tier: "workhorse"
-};
-var REFINE_QUESTION = {
-  name: "refine_question",
-  description: "Refine a question's framing or scope. Like `git commit --amend` for questions \u2014 updates the question text while preserving its identity and linked evidence.",
-  parameters: {
-    id: { type: "string", description: "The question to refine" },
-    text: { type: "string", description: "Updated question text" },
-    rationale: {
-      type: "string",
-      description: "Why the question is being refined"
-    }
-  },
-  required: ["id", "text"],
-  response: {
-    description: "The refined question",
-    fields: {
-      id: "string",
-      questionId: "string",
-      updatedText: "string",
-      previousText: "string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "question",
-  tier: "workhorse"
-};
-var LIST_QUESTIONS = {
-  name: "list_questions",
-  description: "List questions scoped to a topic or worktree. Like `git issue list` \u2014 returns questions with their status, priority, and linked belief context. Supports filtering by status and priority.",
-  parameters: {
-    topicId: { type: "string", description: "Topic scope" },
-    worktreeId: { type: "string", description: "Filter to worktree scope" },
-    status: {
-      type: "string",
-      description: "Filter by canonical question status",
-      enum: ["open", "researching", "answered", "parked", "closed"]
-    },
-    priority: {
-      type: "string",
-      description: "Filter by canonical question priority",
-      enum: ["urgent", "high", "medium", "low"]
-    },
-    limit: { type: "number", description: "Max results" },
-    cursor: { type: "string", description: "Pagination cursor" }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Canonical question page",
-    fields: {
-      questions: "array \u2014 canonical question records",
-      nextCursor: "string | null"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "question",
-  tier: "workhorse"
-};
-var ANSWER_QUESTION = {
-  name: "answer_question",
-  description: "Answer a question with optional evidence links. Like `git commit` on the question thread \u2014 records the answer and closes the loop with a canonical answered state.",
-  parameters: {
-    id: { type: "string", description: "Canonical question ID" },
-    text: { type: "string", description: "Answer text" },
-    confidence: {
-      type: "string",
-      description: "Optional answer confidence",
-      enum: ["weak", "medium", "strong"]
-    },
-    evidenceIds: {
-      type: "array",
-      description: "Optional canonical evidence IDs supporting the answer"
-    },
-    rationale: { type: "string", description: "Why this answer is credible" }
-  },
-  required: ["id", "text"],
-  response: {
-    description: "Answer result",
-    fields: {
-      questionId: "string",
-      answerId: "string",
-      status: "string \u2014 answered"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "question",
-  tier: "workhorse"
-};
-var UPDATE_QUESTION_STATUS = {
-  name: "update_question_status",
-  description: "Transition a question's status through its lifecycle. Like `git issue update` \u2014 moves a question through the canonical reasoning lifecycle. Status transitions preserve history and keep linked evidence intact.",
-  parameters: {
-    id: { type: "string", description: "The question to update" },
-    status: {
-      type: "string",
-      description: "New status",
-      enum: ["open", "researching", "answered", "parked", "closed"]
-    },
-    rationale: { type: "string", description: "Why the status is changing" }
-  },
-  required: ["id", "status"],
-  response: {
-    description: "Updated question status",
-    fields: {
-      id: "string",
-      questionId: "string",
-      previousStatus: "string",
-      newStatus: "string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "question",
-  tier: "workhorse"
-};
-var ARCHIVE_QUESTION = {
-  name: "archive_question",
-  description: "Archive a question no longer relevant to current investigation scope. Like `git issue close` \u2014 removes it from active work while preserving audit history. Archived questions keep their existing links to beliefs and evidence.",
-  parameters: {
-    questionId: { type: "string", description: "The question to archive" },
-    reason: {
-      type: "string",
-      description: "Why the question is being archived"
-    }
-  },
-  required: ["questionId"],
-  response: {
-    description: "Archive confirmation",
-    fields: {
-      questionId: "string",
-      status: "string \u2014 'archived'",
-      archivedAt: "number"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "question",
-  tier: "workhorse"
-};
-var LINK_EVIDENCE_TO_QUESTION = {
-  name: "link_evidence_to_question",
-  description: "Link evidence to the question it helps answer. Like `git notes add` \u2014 attaches supporting detail to an active question. Question-level links improve answer quality and traceability to beliefs.",
-  parameters: {
-    evidenceId: { type: "string", description: "The evidence to link" },
-    questionId: {
-      type: "string",
-      description: "The question this evidence addresses"
-    },
-    relevance: { type: "number", description: "Relevance score in [0,1]" },
-    rationale: {
-      type: "string",
-      description: "How this evidence bears on the question"
-    }
-  },
-  required: ["evidenceId", "questionId"],
-  response: {
-    description: "The created edge",
-    fields: {
-      edgeId: "string",
-      evidenceId: "string",
-      questionId: "string",
-      relevance: "number"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "edge",
-  tier: "workhorse"
-};
-var CREATE_ANSWER = {
-  name: "create_answer",
-  description: "Create an answer node responding to a question. Like `git commit` for resolved questions \u2014 creates an immutable answer snapshot at L2. New answers supersede old ones, preserving full version history. Answers link to supporting evidence via based_on edges.",
-  parameters: {
-    questionNodeId: {
-      type: "string",
-      description: "The question node ID this answers"
-    },
-    answerText: {
-      type: "string",
-      description: "The answer content \u2014 the actual response to the question"
-    },
-    topicId: {
-      type: "string",
-      description: "Topic scope (optional if question already has topicId)"
-    },
-    confidence: {
-      type: "string",
-      description: "Answer confidence: definitive, strong, moderate, weak, speculative"
-    },
-    evidenceNodeIds: {
-      type: "array",
-      description: "Supporting evidence node IDs to link via based_on edges"
-    },
-    answerSource: {
-      type: "string",
-      description: "How the answer was produced: human, ai_generated, deep_research, synthesis"
-    }
-  },
-  required: ["questionNodeId", "answerText"],
-  response: {
-    description: "The created answer node with version metadata",
-    fields: {
-      nodeId: "string \u2014 unique node identifier",
-      globalId: "string \u2014 globally unique ID",
-      versionNumber: "number \u2014 version of this answer (auto-incremented)",
-      questionNodeId: "string \u2014 the question this answers",
-      confidence: "string \u2014 answer confidence level"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "evidence",
-  tier: "showcase"
-};
-var GET_ANSWER = {
-  name: "get_answer",
-  description: "Get the latest answer for a question. Like `git show HEAD` for a question's resolution \u2014 returns the active answer snapshot. Returns null if the question is unanswered.",
-  parameters: {
-    questionNodeId: {
-      type: "string",
-      description: "The question node ID to get the answer for"
-    }
-  },
-  required: ["questionNodeId"],
-  response: {
-    description: "The active answer node or null",
-    fields: {
-      nodeId: "string | null",
-      globalId: "string | null",
-      answerText: "string | null",
-      versionNumber: "number",
-      isLatest: "boolean",
-      evidenceCount: "number",
-      confidence: "string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "evidence",
-  tier: "workhorse"
-};
-var GET_HIGH_PRIORITY_QUESTIONS = {
-  name: "get_high_priority_questions",
-  description: "Rank open questions by urgency and expected decision impact. Like `git issue list --sort=priority` \u2014 brings the highest-leverage open questions to the top. Ranking accounts for linked belief criticality and evidence gaps.",
-  parameters: {
-    topicId: { type: "string", description: "Topic scope" },
-    limit: { type: "number", description: "Maximum results (default: 20)" },
-    includeAnswered: {
-      type: "boolean",
-      description: "Include answered questions (default: false)"
-    }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Priority-ranked questions",
-    fields: {
-      questions: "array \u2014 { questionId, text, priority, urgencyScore, linkedBeliefCount, evidenceGapCount }"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "question",
-  tier: "workhorse"
-};
-var FIND_MISSING_QUESTIONS = {
-  name: "find_missing_questions",
-  description: "Identify beliefs missing testing questions. Like `git diff --check` \u2014 surfaces reasoning coverage gaps before merge. Returns candidate beliefs that need explicit question coverage.",
-  parameters: {
-    topicId: { type: "string", description: "Topic scope" },
-    minConfidence: {
-      type: "number",
-      description: "Only check beliefs above this confidence (default: 0)"
-    }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Beliefs missing testing questions",
-    fields: {
-      gaps: "array \u2014 { beliefId, canonicalText, confidence, suggestedQuestions }",
-      totalGaps: "number"
-    }
-  },
-  ownerModule: "graph-search",
-  ontologyPrimitive: "question",
-  tier: "workhorse"
-};
-var LIST_BELIEFS = {
-  name: "list_beliefs",
-  description: "List beliefs scoped to a topic or worktree. Like `git log --oneline` \u2014 returns beliefs with their confidence, status, and scoring state. Supports filtering by status and confidence threshold.",
-  parameters: {
-    topicId: { type: "string", description: "Topic scope" },
-    worktreeId: { type: "string", description: "Filter to worktree scope" },
-    status: {
-      type: "string",
-      description: "Filter: unscored, scored, archived",
-      enum: ["unscored", "scored", "archived"]
-    },
-    minConfidence: {
-      type: "number",
-      description: "Minimum confidence threshold"
-    }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Canonical belief page",
-    fields: {
-      beliefs: "array \u2014 canonical belief records",
-      nextCursor: "string | null"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "belief",
-  tier: "workhorse"
-};
-var LIST_WORKTREES = {
-  name: "list_worktrees",
-  description: "List all worktrees for a topic. Like `git worktree list` \u2014 shows active and completed investigation branches with their phase, status, and belief counts.",
-  parameters: {
-    topicId: { type: "string", description: "Topic scope" },
-    status: {
-      type: "string",
-      description: "Filter: active, merged, abandoned",
-      enum: ["active", "merged", "abandoned"]
-    }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Worktrees with phase, status, belief count, and creation time",
-    fields: {
-      worktrees: "array \u2014 { worktreeId, title, phase, status, beliefCount, createdAt }"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "worktree",
-  tier: "workhorse"
-};
-var LIST_ALL_WORKTREES = {
-  name: "list_all_worktrees",
-  description: "List ALL worktrees across ALL topics in one query. No topic scope required. Like `git worktree list --all` \u2014 returns the complete pipeline inventory with track, trackPosition, executionBand, dependencies, and status. Supports filtering by status, track, and executionBand. This is the PM's primary pipeline query \u2014 one call, full picture.",
-  parameters: {
-    status: {
-      type: "string",
-      description: "Filter by status: planning, active, completed, abandoned, superseded, long_term, idea, paused, suggested, dismissed",
-      enum: [
-        "planning",
-        "active",
-        "completed",
-        "abandoned",
-        "superseded",
-        "long_term",
-        "idea",
-        "paused",
-        "suggested",
-        "dismissed"
-      ]
-    },
-    track: {
-      type: "string",
-      description: "Filter by track name (e.g., 'ontology', 'tc-scope', 'control-plane', 'dev-portal', 'mcp-sdk-parity')"
-    },
-    executionBand: {
-      type: "number",
-      description: "Filter by execution band number (e.g., 1, 2, 3). Returns only worktrees in that parallel execution group."
-    },
-    limit: {
-      type: "number",
-      description: "Maximum results to return (default: 500, max: 1000)"
-    }
-  },
-  required: [],
-  response: {
-    description: "All worktrees across all topics with full pipeline metadata",
-    fields: {
-      worktrees: "array \u2014 { worktreeId, title, topicId, topicName, phase, status, hypothesis, track, trackPosition, executionBand, executionOrder, dependsOn, blocks, gate, createdAt }",
-      total: "number \u2014 total count after filtering",
-      tracks: "object \u2014 { trackName: count } summary of worktrees per track",
-      bands: "object \u2014 { bandNumber: count } summary of worktrees per execution band"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "worktree",
-  tier: "showcase"
-};
-var ACTIVATE_WORKTREE = {
-  name: "activate_worktree",
-  description: "Activate a worktree to begin investigation. Like `git checkout <branch>` \u2014 transitions a worktree from planning to active status. Sets the initial phase and enables belief/question editing within the worktree scope.",
-  parameters: {
-    worktreeId: { type: "string", description: "The worktree to activate" }
-  },
-  required: ["worktreeId"],
-  response: {
-    description: "Activation result with initial phase",
-    fields: {
-      worktreeId: "string",
-      status: "string \u2014 'active'",
-      phase: "string"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "worktree",
-  tier: "workhorse"
-};
-var UPDATE_WORKTREE_TARGETS = {
-  name: "update_worktree_targets",
-  description: "Update the target beliefs and questions tracked by a worktree. Like `git add/rm <files>` \u2014 stages or unstages beliefs/questions for investigation within the worktree scope. Supports adding and removing targets atomically.",
-  parameters: {
-    worktreeId: { type: "string", description: "The worktree to update" },
-    addBeliefIds: {
-      type: "array",
-      description: "Belief node IDs to add to the worktree"
-    },
-    addQuestionIds: {
-      type: "array",
-      description: "Question node IDs to add to the worktree"
-    },
-    removeBeliefIds: {
-      type: "array",
-      description: "Belief node IDs to remove from the worktree"
-    },
-    removeQuestionIds: {
-      type: "array",
-      description: "Question node IDs to remove from the worktree"
-    }
-  },
-  required: ["worktreeId"],
-  response: {
-    description: "Updated target counts",
-    fields: {
-      worktreeId: "string",
-      beliefCount: "number",
-      questionCount: "number"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "worktree",
-  tier: "workhorse"
-};
-var UPDATE_WORKTREE_METADATA = {
-  name: "update_worktree_metadata",
-  description: "Update worktree sequencing metadata \u2014 execution order, dependencies, blocking relations, and gates. Like `git config` for a worktree \u2014 sets the scheduling and dependency metadata that determines when this worktree can activate relative to others. Use to backfill or correct sequencing data.",
-  parameters: {
-    worktreeId: { type: "string", description: "The worktree to update" },
-    hypothesis: {
-      type: "string",
-      description: "Testable claim this worktree investigates"
-    },
-    executionOrder: {
-      type: "number",
-      description: "Global execution order (1 = first, higher = later)"
-    },
-    dependsOn: {
-      type: "array",
-      description: "Worktree IDs that must complete before this one can activate"
-    },
-    blocks: {
-      type: "array",
-      description: "Worktree IDs that are blocked until this one completes"
-    },
-    gate: {
-      type: "string",
-      description: "Exit gate name (e.g., 'gate:ontology-schema-hardened')"
-    },
-    rationale: {
-      type: "string",
-      description: "Why this worktree is sequenced here"
-    },
-    objective: {
-      type: "string",
-      description: "What we're trying to learn/prove"
-    },
-    proofArtifacts: {
-      type: "array",
-      description: "Typed proof artifacts that define what evidence or deliverables this worktree must emit before it can claim success."
-    },
-    staffingHint: {
-      type: "string",
-      description: "Advisory staffing shape for the worktree (for example `backend+tests` or `fullstack`)."
-    },
-    lastReconciledAt: {
-      type: "number",
-      description: "Timestamp of the last deterministic workflow reconciliation pass against this worktree."
-    },
-    autoFixPolicy: {
-      type: "object",
-      description: "Calibrated auto-fix policy controlling dry-run vs safe execution, per-run action caps, and permitted mutation tiers."
-    },
-    track: {
-      type: "string",
-      description: "Parallel workstream name (e.g., 'ontology', 'tc-scope', 'control-plane', 'dev-portal', 'mcp-sdk-parity', 'execution-program'). Groups worktrees into named lanes for pipeline visualization and PM analysis."
-    },
-    trackPosition: {
-      type: "number",
-      description: "Position within the track (1-indexed). E.g., TC-A=1, TC-B=2, TC-C=3 within the 'tc-scope' track."
-    },
-    executionBand: {
-      type: "number",
-      description: "Parallel execution band number. All worktrees in the same band can run simultaneously. Band 2 = OE-B + TC-A, Band 3 = TC-B + 11D-R + S2-13A, etc."
-    },
-    status: {
-      type: "string",
-      description: "Override the worktree status. Use for lifecycle transitions like marking a worktree superseded, long-term, or as a raw idea.",
-      enum: [
-        "suggested",
-        "planning",
-        "active",
-        "paused",
-        "completed",
-        "dismissed",
-        "abandoned",
-        "superseded",
-        "long_term",
-        "idea"
-      ]
-    },
-    topicId: {
-      type: "string",
-      description: "Reassign this worktree's primary topic. Validates the target topic exists before updating."
-    },
-    additionalTopicIds: {
-      type: "array",
-      description: "Set additional topic associations for cross-topic worktrees. Each topic ID is validated before updating. Use when a worktree spans multiple knowledge domains."
-    }
-  },
-  required: ["worktreeId"],
-  response: {
-    description: "Update confirmation",
-    fields: { worktreeId: "string", success: "boolean" }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "worktree",
-  tier: "workhorse"
-};
-var IDENTITY_WHOAMI = {
-  name: "identity_whoami",
-  description: "Read the authenticated identity summary for the current session. Like `git config --get user.name` \u2014 shows who the current MCP session is acting as.",
-  parameters: {},
-  required: [],
-  response: {
-    description: "Canonical identity summary for the current session",
-    fields: {
-      principalId: "string \u2014 canonical federated principal identifier",
-      principalType: "string \u2014 human, service, or agent",
-      tenantId: "string | undefined \u2014 resolved tenant scope",
-      workspaceId: "string | undefined \u2014 resolved workspace scope",
-      scopes: "string[] | undefined \u2014 granted scopes for this session",
-      roles: "string[] | undefined \u2014 canonical roles for this session"
-    }
-  },
-  ownerModule: "identity-core",
-  ontologyPrimitive: "identity",
-  tier: "workhorse"
-};
-var COMPILE_CONTEXT = {
-  name: "compile_context",
-  description: "Compile a focused reasoning context for a topic. Like `git log --graph --decorate` for the reasoning substrate \u2014 returns the canonical Pillar 3 context pack through the public API shape.",
-  parameters: {
-    topicId: {
-      type: "string",
-      description: "Topic scope ID to compile"
-    },
-    query: {
-      type: "string",
-      description: "Optional focus query used to rank context items"
-    },
-    budget: {
-      type: "number",
-      description: "Token budget for prompt injection planning"
-    },
-    ranking: {
-      type: "string",
-      description: "Ranking profile for context ordering",
-      enum: ["baseline_v1", "weighted_v1"]
-    },
-    limit: {
-      type: "number",
-      description: "Optional per-section item limit"
-    },
-    maxDepth: {
-      type: "number",
-      description: "Optional descendant topic depth for neighborhood expansion"
-    },
-    includeEntities: {
-      type: "boolean",
-      description: "Include related ontological entities in the compiled result"
-    }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Compiled context pack for the requested topic",
-    fields: {
-      schemaVersion: "string",
-      topicId: "string",
-      topicName: "string",
-      scopedTopicIds: "array \u2014 topic IDs included in the compilation neighborhood",
-      generatedAt: "number \u2014 deterministic graph-backed reference timestamp for this compilation",
-      ranking: "string \u2014 baseline_v1 | weighted_v1",
-      summary: "object \u2014 counts and scoped health signals",
-      invariants: "array \u2014 high-confidence invariant beliefs",
-      activeBeliefs: "array \u2014 current high-signal beliefs",
-      openQuestions: "array \u2014 unresolved questions ranked for this query",
-      recentEvidence: "array \u2014 recent evidence ranked for this query",
-      contradictions: "array \u2014 unresolved contradiction records",
-      relatedEntities: "array | undefined \u2014 ranked ontological entities in scope",
-      contextNarrative: "array \u2014 guidance for prompt assembly",
-      injectionPolicy: "object \u2014 token-budgeted section selections",
-      diagnostics: "object \u2014 scoring and utilization telemetry"
-    }
-  },
-  ownerModule: "reasoning-kernel",
-  ontologyPrimitive: "graph",
-  tier: "showcase"
-};
-var CHECK_PERMISSION = {
-  name: "check_permission",
-  description: "Check whether a principal can read or mutate a topic scope. Like `git check-ref-format` for ACLs \u2014 validates whether the requested operation is allowed before execution.",
-  parameters: {
-    topicId: { type: "string", description: "Topic scope to evaluate" },
-    permission: {
-      type: "string",
-      description: "Permission to evaluate",
-      enum: ["read", "write"]
-    },
-    principal: {
-      type: "string",
-      description: "Optional principal override (defaults to current principal)"
-    },
-    beliefClusterId: {
-      type: "string",
-      description: "Optional neighborhood scope within a topic"
-    }
-  },
-  required: ["topicId", "permission"],
-  response: {
-    description: "Permission evaluation result",
-    fields: {
-      allowed: "boolean",
-      decision: "string \u2014 allow | deny",
-      reasonCode: "string",
-      principalId: "string",
-      topicId: "string",
-      permission: "string \u2014 read | write"
-    }
-  },
-  ownerModule: "access-control",
-  ontologyPrimitive: "policy",
-  tier: "workhorse"
-};
-var FILTER_BY_PERMISSION = {
-  name: "filter_by_permission",
-  description: "Filter a topic set down to ACL-authorized topics. Like `git rev-list --ancestry-path` for policy boundaries \u2014 keeps only topics permitted for the requested action.",
-  parameters: {
-    topicIds: { type: "array", description: "Topic IDs to evaluate" },
-    permission: {
-      type: "string",
-      description: "Permission filter",
-      enum: ["read", "write"]
-    },
-    principal: {
-      type: "string",
-      description: "Optional principal override (tenant admin only)"
-    }
-  },
-  required: ["topicIds", "permission"],
-  response: {
-    description: "Allowed/denied split for the requested topic set",
-    fields: {
-      permission: "string \u2014 read | write",
-      allowedTopicIds: "array \u2014 topic IDs allowed by policy",
-      deniedTopics: "array \u2014 { topicId, reasonCode }",
-      count: "number"
-    }
-  },
-  ownerModule: "access-control",
-  ontologyPrimitive: "policy",
-  tier: "workhorse"
-};
-var INGEST_OBSERVATION = {
-  name: "ingest_observation",
-  description: "Record an observational delta for a topic context stream. Like `git notes add` \u2014 attaches structured observation metadata without mutating graph state directly. Used by watcher/cowork agents to stage candidate updates before explicit write confirmation.",
-  parameters: {
-    topicId: {
-      type: "string",
-      description: "Topic scope for the observation"
-    },
-    observationType: {
-      type: "string",
-      description: "Observation class",
-      enum: [
-        "claim",
-        "evidence",
-        "question",
-        "contradiction",
-        "judgment",
-        "note"
-      ]
-    },
-    summary: {
-      type: "string",
-      description: "Human-readable observation summary"
-    },
-    source: {
-      type: "string",
-      description: "Optional source (message ID, tool name, URL, etc.)"
-    },
-    confidence: { type: "number", description: "Optional confidence in [0,1]" },
-    tags: { type: "array", description: "Optional observation tags" },
-    metadata: {
-      type: "object",
-      description: "Optional structured metadata payload"
-    }
-  },
-  required: ["topicId", "observationType", "summary"],
-  response: {
-    description: "Recorded observation entry",
-    fields: {
-      observationId: "string",
-      topicId: "string",
-      observationType: "string",
-      createdAt: "number",
-      contextResourceUri: "string"
-    }
-  },
-  ownerModule: "agent-harness",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var GET_OBSERVATION_CONTEXT = {
-  name: "get_observation_context",
-  description: "Retrieve observer-ready context for a topic, including recent deltas and semantic matches. Like `git log --grep` \u2014 shows recent context and filtered matches across observation history. This powers prompt context injection without mutating graph state.",
-  parameters: {
-    topicId: { type: "string", description: "Topic scope" },
-    query: {
-      type: "string",
-      description: "Optional semantic query over observation history"
-    },
-    limit: {
-      type: "number",
-      description: "Maximum entries in each returned collection"
-    }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Observation context payload",
-    fields: {
-      topicId: "string",
-      totalObservations: "number",
-      latest: "array",
-      semanticMatches: "array",
-      byType: "object",
-      generatedAt: "number"
-    }
-  },
-  ownerModule: "agent-harness",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var CREATE_TASK = {
-  name: "create_task",
-  description: "Create an execution task tied to the reasoning state. Like `git task` \u2014 tracks concrete work items (calls to make, data to gather, analyses to run) linked to questions, beliefs, or worktrees.",
-  parameters: {
-    title: { type: "string", description: "Task description" },
-    topicId: { type: "string", description: "Topic scope" },
-    taskType: {
-      type: "string",
-      description: "Type: research, interview, analysis, data_collection",
-      enum: ["research", "interview", "analysis", "data_collection"]
-    },
-    linkedQuestionId: {
-      type: "string",
-      description: "Question this task addresses"
-    },
-    linkedWorktreeId: { type: "string", description: "Worktree scope" }
-  },
-  required: ["title", "topicId"],
-  response: {
-    description: "The created task",
-    fields: {
-      taskId: "string",
-      status: "string \u2014 'pending'",
-      createdAt: "number"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "task",
-  tier: "workhorse"
-};
-var COMPLETE_TASK = {
-  name: "complete_task",
-  description: "Mark a task as complete with an output summary. Like `git tag` for work items \u2014 records the discrete completion event and captures what was learned. Completed tasks feed back into the evidence graph.",
-  parameters: {
-    taskId: { type: "string", description: "The task to complete" },
-    outputSummary: {
-      type: "string",
-      description: "What was accomplished or learned"
-    },
-    evidenceCreated: {
-      type: "boolean",
-      description: "Whether new evidence was created from this task"
-    }
-  },
-  required: ["taskId", "outputSummary"],
-  response: {
-    description: "The completed task",
-    fields: {
-      taskId: "string",
-      completedAt: "number",
-      outputSummary: "string"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "task",
-  tier: "workhorse"
-};
-var UPDATE_TASK = {
-  name: "update_task",
-  description: "Update a task's fields \u2014 relink to a different worktree, belief, or question, change title/priority/status. Like `git task edit` \u2014 mutates an existing task in place instead of requiring recreate-plus-supersede.",
-  parameters: {
-    taskId: { type: "string", description: "The task to update" },
-    linkedWorktreeId: {
-      type: "string",
-      description: "Reassign this task to a different worktree"
-    },
-    linkedBeliefId: {
-      type: "string",
-      description: "Link or relink this task to a belief node"
-    },
-    linkedQuestionId: {
-      type: "string",
-      description: "Link or relink this task to a question node"
-    },
-    title: { type: "string", description: "Updated task title" },
-    description: {
-      type: "string",
-      description: "Updated task description"
-    },
-    priority: {
-      type: "string",
-      description: "Updated priority",
-      enum: ["critical", "high", "medium", "low"]
-    },
-    status: {
-      type: "string",
-      description: "Updated status",
-      enum: ["todo", "in_progress", "blocked", "done"]
-    }
-  },
-  required: ["taskId"],
-  response: {
-    description: "The updated task",
-    fields: {
-      taskId: "string",
-      updatedAt: "number"
-    }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "task",
-  tier: "workhorse"
-};
-var LIST_TASKS = {
-  name: "list_tasks",
-  description: "List tasks for a topic or worktree. Like `git task list` \u2014 returns tasks with status, priority, and linked nodes. Filter by worktree to see tasks for a specific investigation, or by status to find incomplete work.",
-  parameters: {
-    topicId: { type: "string", description: "Topic scope" },
-    linkedWorktreeId: {
-      type: "string",
-      description: "Filter to tasks linked to this worktree"
-    },
-    status: {
-      type: "string",
-      description: "Filter by status: todo, in_progress, blocked, done",
-      enum: ["todo", "in_progress", "blocked", "done"]
-    },
-    limit: { type: "number", description: "Maximum results (default: 100)" }
-  },
-  required: ["topicId"],
-  response: {
-    description: "List of tasks with metadata",
-    fields: { tasks: "array of task objects", count: "number" }
-  },
-  ownerModule: "workflow-engine",
-  ontologyPrimitive: "task",
-  tier: "workhorse"
-};
-var CREATE_TOPIC = {
-  name: "create_topic",
-  description: "Create a new topic container for scoping knowledge. Like `git init` \u2014 initializes a new repository for a knowledge domain. Topics are hierarchical: a deal topic can nest under a theme topic. Types: domain, theme, deal, strategy, constitution, project, portfolio.",
-  parameters: {
-    name: { type: "string", description: "Topic name" },
-    type: {
-      type: "string",
-      description: "Topic type. Validated against schemaEnumConfig category 'topic_type'."
-    },
-    description: { type: "string", description: "What this topic covers" },
-    parentTopicId: {
-      type: "string",
-      description: "Optional parent topic for nesting"
-    },
-    createdBy: { type: "string", description: "Who created this topic" }
-  },
-  required: ["name", "type"],
-  response: {
-    description: "The created topic",
-    fields: {
-      id: "string \u2014 topic ID",
-      globalId: "string \u2014 globally unique ID",
-      depth: "number \u2014 nesting depth"
-    }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "graph",
-  tier: "showcase"
-};
-var LIST_TOPICS = {
-  name: "list_topics",
-  description: "List topics, optionally filtered by type or parent. Like `git remote -v` \u2014 shows all knowledge containers with their types and hierarchy.",
-  parameters: {
-    type: {
-      type: "string",
-      description: "Filter by topic type (e.g., 'theme', 'deal')"
-    },
-    parentTopicId: {
-      type: "string",
-      description: "Filter to children of this parent"
-    },
-    status: {
-      type: "string",
-      description: "Filter by status",
-      enum: ["active", "archived", "watching"]
-    }
-  },
-  required: [],
-  response: {
-    description: "List of topics with metadata",
-    fields: {
-      topics: "array \u2014 { id, name, type, depth, status, parentTopicId }"
-    }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var GET_TOPIC = {
-  name: "get_topic",
-  description: "Get one topic by ID. Like `git remote show origin` \u2014 inspects a single knowledge container in detail.",
-  parameters: {
-    topicId: {
-      type: "string",
-      description: "Canonical topic ID to retrieve"
-    },
-    id: {
-      type: "string",
-      description: "Legacy alias for topicId"
-    }
-  },
-  required: [],
-  response: {
-    description: "Single topic record",
-    fields: {
-      topic: "object \u2014 { id, globalId, name, type, depth, status, parentTopicId, description }"
-    }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var UPDATE_TOPIC = {
-  name: "update_topic",
-  description: "Update an existing topic's metadata. Like `git remote set-url` \u2014 changes the canonical configuration for a knowledge container without recreating it.",
-  parameters: {
-    topicId: {
-      type: "string",
-      description: "Canonical topic ID to update"
-    },
-    id: {
-      type: "string",
-      description: "Legacy alias for topicId"
-    },
-    name: { type: "string", description: "Updated topic name" },
-    description: { type: "string", description: "Updated topic description" },
-    type: {
-      type: "string",
-      description: "Updated topic type. Validated against schemaEnumConfig category 'topic_type'."
-    },
-    ontologyId: {
-      type: "string",
-      description: "Updated ontology binding"
-    },
-    clearOntologyId: {
-      type: "boolean",
-      description: "Clear the current ontology binding"
-    },
-    status: {
-      type: "string",
-      description: "Updated topic status",
-      enum: ["active", "archived", "watching"]
-    },
-    visibility: {
-      type: "string",
-      description: "Updated topic visibility",
-      enum: ["private", "team", "firm", "external", "public"]
-    }
-  },
-  required: [],
-  response: {
-    description: "The updated topic",
-    fields: {
-      id: "string \u2014 topic ID",
-      globalId: "string \u2014 globally unique ID",
-      status: "string \u2014 topic lifecycle status",
-      visibility: "string \u2014 topic visibility"
-    }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var GET_TOPIC_TREE = {
-  name: "get_topic_tree",
-  description: "Get the full topic hierarchy from a root. Like `git log --graph --all` \u2014 shows the complete tree of nested topics.",
-  parameters: {
-    rootId: { type: "string", description: "Root topic to start from" },
-    maxDepth: {
-      type: "number",
-      description: "Maximum depth to traverse (default: 5)"
-    }
-  },
-  required: ["rootId"],
-  response: {
-    description: "Tree of topics with nesting",
-    fields: { tree: "array \u2014 topics in BFS order with depth and path" }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "graph",
-  tier: "workhorse"
-};
-var GET_CODE_CONTEXT = {
-  name: "get_code_context",
-  description: "Returns code-grounded beliefs, contracts, migration states, and failed attempts anchored to a specific file or function path. Like `git log -- <path>` \u2014 filters the knowledge graph to nodes anchored to a file path via metadata.codeAnchors. Results are separated by coding belief type: decisions, contracts, migrations, patterns, deprecations, and failures.",
-  parameters: {
-    filePath: {
-      type: "string",
-      description: "File path to search for (partial matches supported, e.g. 'epistemicBeliefs.ts' or 'convex/epistemicBeliefs.ts')"
-    },
-    topicId: {
-      type: "string",
-      description: "Topic scope (optional, uses default if not provided)"
-    },
-    includeFailures: {
-      type: "boolean",
-      description: "Whether to include failed attempt evidence (default: true)"
-    }
-  },
-  required: ["filePath"],
-  response: {
-    description: "Code-anchored beliefs and evidence grouped by type",
-    fields: {
-      filePath: "string \u2014 queried path",
-      decisions: "array \u2014 implementation_decision beliefs",
-      contracts: "array \u2014 interface_contract beliefs",
-      migrations: "array \u2014 migration_state beliefs",
-      patterns: "array \u2014 code_pattern beliefs",
-      deprecations: "array \u2014 deprecation_notice beliefs",
-      failures: "array \u2014 failed attempt evidence",
-      totalMatched: "number"
-    }
-  },
-  ownerModule: "coding-intelligence",
-  ontologyPrimitive: "belief",
-  tier: "showcase"
-};
-var GET_CHANGE_HISTORY = {
-  name: "get_change_history",
-  description: "Returns recent changes and decisions for a file path \u2014 the 'why' behind recent code changes. Like `git log --follow <path>` \u2014 shows the evolution of understanding anchored to a specific file. Searches beliefs and evidence updated recently, sorted by most recent first.",
-  parameters: {
-    filePath: { type: "string", description: "File path to get history for" },
-    topicId: { type: "string", description: "Topic scope (optional)" },
-    limit: { type: "number", description: "Max results (default: 10)" }
-  },
-  required: ["filePath"],
-  response: {
-    description: "Recent code-anchored changes sorted by recency",
-    fields: {
-      filePath: "string \u2014 queried path",
-      changes: "array \u2014 nodes with coding view (nodeId, beliefType, canonicalText, codeAnchors, timestamps)",
-      totalFound: "number",
-      showing: "number"
-    }
-  },
-  ownerModule: "coding-intelligence",
-  ontologyPrimitive: "belief",
-  tier: "workhorse"
-};
-var RECORD_ATTEMPT = {
-  name: "record_attempt",
-  description: "Log a failed approach as evidence linked to a belief. Like `git stash` for failed experiments \u2014 preserves what was tried so the same mistake isn't repeated. Creates evidence with metadata.failedApproach=true and metadata.codeAnchors. The key anti-repetition mechanism: future agents check the failure log before trying new approaches.",
-  parameters: {
-    description: {
-      type: "string",
-      description: "What was attempted and why it failed"
-    },
-    filePaths: {
-      type: "array",
-      description: "File paths involved in the attempt"
-    },
-    errorMessage: {
-      type: "string",
-      description: "Error message or failure reason"
-    },
-    linkedBeliefId: {
-      type: "string",
-      description: "Belief this attempt was targeting (creates -0.5 weight edge)"
-    },
-    topicId: { type: "string", description: "Topic scope (optional)" }
-  },
-  required: ["description"],
-  response: {
-    description: "The recorded failed attempt evidence node",
-    fields: {
-      nodeId: "string \u2014 evidence node ID",
-      edgeId: "string | null \u2014 edge to linked belief",
-      recorded: "boolean \u2014 true",
-      filePaths: "array \u2014 anchored file paths"
-    }
-  },
-  ownerModule: "coding-intelligence",
-  ontologyPrimitive: "evidence",
-  tier: "showcase"
-};
-var GET_FAILURE_LOG = {
-  name: "get_failure_log",
-  description: "Search past failed attempts matching a task description. Like `git log --grep='FAILED'` \u2014 finds evidence of what was tried before and didn't work. Before trying a new approach, check this log to avoid repeating the same mistake. Filters to evidence with metadata.failedApproach=true, sorted by recency.",
-  parameters: {
-    query: {
-      type: "string",
-      description: "Description of the task or approach to search for"
-    },
-    filePath: {
-      type: "string",
-      description: "Optional file path to narrow results"
-    },
-    topicId: { type: "string", description: "Topic scope (optional)" },
-    limit: { type: "number", description: "Max results (default: 5)" }
-  },
-  required: ["query"],
-  response: {
-    description: "Failed attempts matching the query",
-    fields: {
-      query: "string \u2014 search query",
-      failures: "array \u2014 failed attempt evidence with coding view",
-      totalFound: "number",
-      showing: "number"
-    }
-  },
-  ownerModule: "coding-intelligence",
-  ontologyPrimitive: "evidence",
-  tier: "showcase"
-};
-var GET_TOPIC_COVERAGE = {
-  name: "get_topic_coverage",
-  description: "Returns per-topic belief/question/evidence counts across the topic tree. Like `git diff --stat` for the knowledge graph \u2014 shows coverage density and empty spots across the topic hierarchy. Use to identify which topics need more beliefs, which lack questions, and overall graph health.",
-  parameters: {
-    topicId: {
-      type: "string",
-      description: "Topic scope ID (optional, uses default if not provided)"
-    },
-    includeDescendants: {
-      type: "boolean",
-      description: "Whether to include descendant topics in the coverage report (default: true)"
-    },
-    maxDepth: {
-      type: "number",
-      description: "Maximum descendant topic depth for neighborhood expansion. Defaults to 4 for root/theme scopes, 2 for deeper scopes."
-    }
-  },
-  required: [],
-  response: {
-    description: "Per-topic coverage metrics and aggregate summary",
-    fields: {
-      topics: "array \u2014 per-topic { topicId, name, type, depth, beliefs, questions, evidence, coverage }",
-      summary: "object \u2014 { totalTopics, coveredTopics, emptyTopics, coveragePercent, totalBeliefs, totalQuestions, totalEvidence }",
-      scopeTopicId: "string \u2014 the root topic used for scoping"
-    }
-  },
-  ownerModule: "coverage-intelligence",
-  ontologyPrimitive: "graph",
-  tier: "showcase"
-};
-var GET_GRAPH_GAPS = {
-  name: "get_graph_gaps",
-  description: "Identify structural gaps in the knowledge graph \u2014 empty topics, beliefs without questions, beliefs without evidence, and orphan edges. Like `git fsck` for reasoning coverage \u2014 surfaces holes that weaken the epistemic foundation. Returns prioritized gap list.",
-  parameters: {
-    topicId: {
-      type: "string",
-      description: "Topic scope ID (optional, uses default if not provided)"
-    },
-    maxDepth: {
-      type: "number",
-      description: "Maximum descendant topic depth for neighborhood expansion (default: 4)"
-    }
-  },
-  required: ["topicId"],
-  response: {
-    description: "Prioritized list of graph gaps by category",
-    fields: {
-      emptyTopics: "array \u2014 topics with zero beliefs { topicId, name, type, depth }",
-      beliefsWithoutQuestions: "array \u2014 beliefs that have no testing questions { nodeId, canonicalText, topicId }",
-      beliefsWithoutEvidence: "array \u2014 beliefs that have no supporting evidence { nodeId, canonicalText, topicId }",
-      summary: "object \u2014 { totalGaps, emptyTopicCount, untestedBeliefCount, unsupportedBeliefCount }",
-      scopeTopicId: "string \u2014 the root topic used for scoping"
-    }
-  },
-  ownerModule: "coverage-intelligence",
-  ontologyPrimitive: "graph",
-  tier: "showcase"
-};
-var MANAGE_WRITE_POLICY = {
-  name: "manage_write_policy",
-  description: "Manage write policies for MCP mutation tools. Like `git config` for write permissions \u2014 sets per-topic or global policies that control which roles can mutate the graph.",
-  parameters: {
-    action: {
-      type: "string",
-      description: "Action to perform: 'get' (read policies) or 'set' (upsert a policy)",
-      enum: ["get", "set"]
-    },
-    topicId: {
-      type: "string",
-      description: "Topic scope for the policy. Omit for global policies."
-    },
-    role: {
-      type: "string",
-      description: "Role to set policy for (required for 'set'). E.g. 'agent:internal', 'user:analyst'."
-    },
-    permission: {
-      type: "string",
-      description: "Permission level (required for 'set').",
-      enum: ["allow", "deny", "read_only"]
-    },
-    maxWritesPerSession: {
-      type: "number",
-      description: "Optional per-session write limit for this role+scope."
-    },
-    rationale: {
-      type: "string",
-      description: "Why this policy is being set (audit trail)."
-    }
-  },
-  required: ["action"],
-  response: {
-    description: "Policy operation result",
-    fields: {
-      action: "string \u2014 get | set",
-      topicId: "string|null \u2014 topic scope or null for global",
-      policies: "array \u2014 (for get) list of matching policies",
-      role: "string \u2014 (for set) role that was updated",
-      permission: "string \u2014 (for set) new permission level",
-      maxWritesPerSession: "number|null \u2014 (for set) session write cap"
-    }
-  },
-  ownerModule: "access-control",
-  ontologyPrimitive: "policy",
-  tier: "workhorse"
-};
-var LIST_ONTOLOGIES = {
-  name: "list_ontologies",
-  description: "List ontology definitions with optional filters. Like `git remote -v` for ontologies \u2014 shows all registered ontology definitions with their tier, status, and tenant scope.",
-  parameters: {
-    tenantId: {
-      type: "string",
-      description: "Filter by tenant ID. Omit for platform-level ontologies."
-    },
-    tier: {
-      type: "string",
-      description: "Filter by tier",
-      enum: ["platform", "pack", "tenant"]
-    },
-    status: {
-      type: "string",
-      description: "Filter by status",
-      enum: ["draft", "active", "deprecated", "archived"]
-    }
-  },
-  required: [],
-  response: {
-    description: "Array of ontology definitions",
-    fields: {
-      ontologies: "array \u2014 ontology definitions with id, ontologyKey, name, tier, status"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "ontology",
-  tier: "showcase"
-};
-var GET_ONTOLOGY = {
-  name: "get_ontology",
-  description: "Get a single ontology definition by ID or ontologyKey. Like `git show` for an ontology \u2014 returns the definition metadata plus the latest published version with entity types and edge types.",
-  parameters: {
-    id: {
-      type: "string",
-      description: "Ontology definition ID (Convex document ID)"
-    },
-    ontologyKey: {
-      type: "string",
-      description: "Ontology key (e.g., 'investment-ontology'). Alternative to id."
-    },
-    tenantId: {
-      type: "string",
-      description: "Tenant scope for key lookup. Omit for platform-level."
-    }
-  },
-  required: [],
-  response: {
-    description: "Ontology definition with latest published version",
-    fields: {
-      id: "string \u2014 definition ID",
-      ontologyKey: "string \u2014 unique key",
-      name: "string \u2014 display name",
-      publishedVersion: "object|null \u2014 latest published version with entityTypes and edgeTypes"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "ontology",
-  tier: "showcase"
-};
-var APPLY_ONTOLOGY = {
-  name: "apply_ontology",
-  description: "Bind an ontology definition directly to a topic. Like `git checkout` for a domain vocabulary \u2014 applies an ontology to a topic so the topic and its descendants inherit the configured entity and edge schema.",
-  parameters: {
-    ontologyId: {
-      type: "string",
-      description: "Canonical ontology identifier to bind"
-    },
-    topicId: {
-      type: "string",
-      description: "Canonical topic identifier to receive the binding"
-    }
-  },
-  required: ["ontologyId", "topicId"],
-  response: {
-    description: "Ontology binding summary",
-    fields: {
-      applied: "boolean \u2014 true when the binding was written",
-      source: "string \u2014 always 'direct' for an explicit bind",
-      ontologyId: "string \u2014 canonical ontology ID",
-      ontologyKey: "string \u2014 ontology key",
-      topicId: "string \u2014 canonical topic ID"
-    }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "ontology",
-  tier: "showcase"
-};
-var MATCH_ENTITY_TYPE = {
-  name: "match_entity_type",
-  description: "Classify free text against the effective ontology vocabulary. Like `git grep` for ontology types \u2014 ranks the most likely entity types for the supplied text using the topic-bound or explicitly selected ontology.",
-  parameters: {
-    text: {
-      type: "string",
-      description: "Free text to classify against ontology entity types"
-    },
-    topicId: {
-      type: "string",
-      description: "Canonical topic ID used to resolve the effective ontology when ontologyId is omitted"
-    },
-    ontologyId: {
-      type: "string",
-      description: "Optional ontology definition ID to match against instead of the topic-bound ontology"
-    },
-    minScore: {
-      type: "number",
-      description: "Optional lower similarity bound for returned matches"
-    },
-    limit: {
-      type: "number",
-      description: "Optional maximum number of ranked matches to return"
-    }
-  },
-  required: ["text"],
-  response: {
-    description: "Ranked ontology entity type matches",
-    fields: {
-      matches: "array \u2014 ranked entity type matches with score, entityType, label, and optional description",
-      ontologyId: "string|null \u2014 ontology used for matching",
-      topicId: "string|null \u2014 topic scope used for ontology resolution"
-    }
-  },
-  ownerModule: "schema-management",
-  ontologyPrimitive: "ontology",
-  tier: "showcase"
-};
-var CREATE_ONTOLOGY = {
-  name: "create_ontology",
-  description: "Create a new ontology definition. Like `git init` for a domain vocabulary \u2014 creates a named, versioned container for entity types and edge types. Starts in 'draft' status.",
-  parameters: {
-    ontologyKey: {
-      type: "string",
-      description: "Unique key (lowercase, hyphens, e.g., 'investment-ontology')"
-    },
-    name: { type: "string", description: "Human-readable name" },
-    description: { type: "string", description: "What this ontology covers" },
-    tenantId: {
-      type: "string",
-      description: "Tenant scope. Omit for platform-level."
-    },
-    tier: {
-      type: "string",
-      description: "Ontology tier",
-      enum: ["platform", "pack", "tenant"]
-    },
-    parentOntologyId: {
-      type: "string",
-      description: "Parent ontology ID for layered composition"
-    }
-  },
-  required: ["ontologyKey", "name", "tier"],
-  response: {
-    description: "Created ontology definition",
-    fields: {
-      id: "string \u2014 new definition ID",
-      ontologyKey: "string \u2014 normalized key"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "ontology",
-  tier: "showcase"
-};
-var UPDATE_ONTOLOGY = {
-  name: "update_ontology",
-  description: "Update an ontology definition's metadata (name, description, status). Like `git config` for an ontology \u2014 updates mutable fields on the definition. Only allowed while the ontology is in draft or active status.",
-  parameters: {
-    id: { type: "string", description: "Ontology definition ID" },
-    name: { type: "string", description: "New display name" },
-    description: { type: "string", description: "New description" },
-    status: {
-      type: "string",
-      description: "New status",
-      enum: ["draft", "active", "deprecated"]
-    }
-  },
-  required: ["id"],
-  response: {
-    description: "Update confirmation",
-    fields: { success: "boolean" }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "ontology",
-  tier: "workhorse"
-};
-var ARCHIVE_ONTOLOGY = {
-  name: "archive_ontology",
-  description: "Archive an ontology definition. Like `git rm` for an ontology \u2014 soft-deletes the definition. Archived ontologies are preserved in history but no longer active.",
-  parameters: {
-    id: { type: "string", description: "Ontology definition ID to archive" }
-  },
-  required: ["id"],
-  response: {
-    description: "Archive confirmation",
-    fields: { success: "boolean" }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "ontology",
-  tier: "workhorse"
-};
-var CREATE_ONTOLOGY_VERSION = {
-  name: "create_ontology_version",
-  description: "Create a new version snapshot for an ontology definition. Like `git commit` for ontology content \u2014 captures entity types and edge types in a versioned snapshot. Starts in 'draft' status. Publish to freeze.",
-  parameters: {
-    ontologyId: {
-      type: "string",
-      description: "Parent ontology definition ID"
-    },
-    version: {
-      type: "string",
-      description: "Semantic version string (X.Y.Z format)"
-    },
-    entityTypes: {
-      type: "array",
-      description: "Array of entity type definitions: [{ value, label, description?, schema?, subtypes? }]"
-    },
-    edgeTypes: {
-      type: "array",
-      description: "Array of edge type definitions: [{ value, label, description?, sourceTypes?, targetTypes?, constraintSeverity? }]"
-    },
-    releaseNotes: {
-      type: "string",
-      description: "Optional release notes for this version"
-    }
-  },
-  required: ["ontologyId", "version", "entityTypes", "edgeTypes"],
-  response: {
-    description: "Created version",
-    fields: {
-      id: "string \u2014 new version ID",
-      version: "string \u2014 version string"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "ontology",
-  tier: "showcase"
-};
-var PUBLISH_ONTOLOGY_VERSION = {
-  name: "publish_ontology_version",
-  description: "Publish a draft ontology version \u2014 freezes it permanently. Like `git tag` for an ontology release \u2014 the version becomes immutable after publish. If the parent definition is still in 'draft', promotes it to 'active'.",
-  parameters: {
-    id: { type: "string", description: "Ontology version ID to publish" }
-  },
-  required: ["id"],
-  response: {
-    description: "Publish confirmation",
-    fields: {
-      success: "boolean",
-      publishedAt: "number \u2014 timestamp"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "ontology",
-  tier: "showcase"
-};
-var DEPRECATE_ONTOLOGY_VERSION = {
-  name: "deprecate_ontology_version",
-  description: "Deprecate a published ontology version. Like `git tag -d` for an ontology release \u2014 marks the version as deprecated. Only published versions can be deprecated.",
-  parameters: {
-    id: { type: "string", description: "Ontology version ID to deprecate" }
-  },
-  required: ["id"],
-  response: {
-    description: "Deprecation confirmation",
-    fields: { success: "boolean" }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "ontology",
-  tier: "workhorse"
-};
-var RESOLVE_EFFECTIVE_ONTOLOGY = {
-  name: "resolve_effective_ontology",
-  description: "Resolve the effective ontology by composing the parent chain. Like `git merge --squash` for ontology layers \u2014 walks parentOntologyId chain (max depth 3) and merges entity/edge types additively from root (platform) to leaf (tenant).",
-  parameters: {
-    ontologyId: {
-      type: "string",
-      description: "Ontology definition ID to resolve from"
-    }
-  },
-  required: ["ontologyId"],
-  response: {
-    description: "Merged ontology with composed entity and edge types",
-    fields: {
-      entityTypes: "array \u2014 merged entity types from all layers",
-      edgeTypes: "array \u2014 merged edge types from all layers",
-      layers: "array \u2014 ontology keys in composition order"
-    }
-  },
-  ownerModule: "graph-primitives",
-  ontologyPrimitive: "ontology",
-  tier: "workhorse"
-};
-var MCP_TOOL_CONTRACTS = {
-  // Belief lifecycle (commit, amend, fork, archive)
-  create_belief: CREATE_BELIEF,
-  get_belief: GET_BELIEF,
-  refine_belief: REFINE_BELIEF,
-  modulate_confidence: MODULATE_CONFIDENCE,
-  fork_belief: FORK_BELIEF,
-  archive_belief: ARCHIVE_BELIEF,
-  create_epistemic_contract: CREATE_EPISTEMIC_CONTRACT,
-  // Evidence (commit)
-  create_evidence: CREATE_EVIDENCE,
-  get_evidence: GET_EVIDENCE,
-  list_evidence: LIST_EVIDENCE,
-  link_evidence: LINK_EVIDENCE,
-  add_evidence: ADD_EVIDENCE,
-  // Contradictions (merge conflict)
-  flag_contradiction: FLAG_CONTRADICTION,
-  // Lens lifecycle (workspace-scoped operational frames)
-  create_lens: CREATE_LENS,
-  list_lenses: LIST_LENSES,
-  apply_lens_to_topic: APPLY_LENS_TO_TOPIC,
-  remove_lens_from_topic: REMOVE_LENS_FROM_TOPIC,
-  // Worktree lifecycle (git worktree add → merge → push → pull request)
-  add_worktree: ADD_WORKTREE,
-  merge: MERGE,
-  push: PUSH,
-  open_pull_request: OPEN_PULL_REQUEST,
-  // Lineage and audit (log, blame)
-  query_lineage: QUERY_LINEAGE,
-  get_confidence_history: GET_CONFIDENCE_HISTORY,
-  get_audit_trail: GET_AUDIT_TRAIL,
-  // Graph queries (traverse, search, bisect, entity impact)
-  traverse_graph: TRAVERSE_GRAPH,
-  get_graph_neighborhood: GET_GRAPH_NEIGHBORHOOD,
-  trace_entity_impact: TRACE_ENTITY_IMPACT,
-  search_beliefs: SEARCH_BELIEFS,
-  search_resources: SEARCH_RESOURCES,
-  find_contradictions: FIND_CONTRADICTIONS,
-  bisect_confidence: BISECT_CONFIDENCE,
-  // Edges (commit)
-  create_edge: CREATE_EDGE,
-  // Judgments (tag)
-  record_judgment: RECORD_JUDGMENT,
-  // Graph intelligence (showcase)
-  detect_confirmation_bias: DETECT_CONFIRMATION_BIAS,
-  get_graph_structure_analysis: GET_GRAPH_STRUCTURE_ANALYSIS,
-  get_falsification_questions: GET_FALSIFICATION_QUESTIONS,
-  // Sources & research (showcase)
-  search_sources: SEARCH_SOURCES,
-  execute_deep_research: EXECUTE_DEEP_RESEARCH,
-  // Evidence operations (workhorse)
-  search_evidence: SEARCH_EVIDENCE,
-  link_evidence_to_belief: LINK_EVIDENCE_TO_BELIEF,
-  // Answer lifecycle (L2 question responses)
-  create_answer: CREATE_ANSWER,
-  get_answer: GET_ANSWER,
-  // Question operations (workhorse)
-  create_question: CREATE_QUESTION,
-  get_question: GET_QUESTION,
-  refine_question: REFINE_QUESTION,
-  list_questions: LIST_QUESTIONS,
-  answer_question: ANSWER_QUESTION,
-  update_question_status: UPDATE_QUESTION_STATUS,
-  archive_question: ARCHIVE_QUESTION,
-  link_evidence_to_question: LINK_EVIDENCE_TO_QUESTION,
-  get_high_priority_questions: GET_HIGH_PRIORITY_QUESTIONS,
-  find_missing_questions: FIND_MISSING_QUESTIONS,
-  // Listing & query (workhorse)
-  list_beliefs: LIST_BELIEFS,
-  list_worktrees: LIST_WORKTREES,
-  list_all_worktrees: LIST_ALL_WORKTREES,
-  activate_worktree: ACTIVATE_WORKTREE,
-  update_worktree_targets: UPDATE_WORKTREE_TARGETS,
-  update_worktree_metadata: UPDATE_WORKTREE_METADATA,
-  identity_whoami: IDENTITY_WHOAMI,
-  compile_context: COMPILE_CONTEXT,
-  // Policy / ACL (workhorse)
-  check_permission: CHECK_PERMISSION,
-  filter_by_permission: FILTER_BY_PERMISSION,
-  // Write policy (S2-13K Graph Compounding)
-  manage_write_policy: MANAGE_WRITE_POLICY,
-  // Observation context (workhorse)
-  ingest_observation: INGEST_OBSERVATION,
-  get_observation_context: GET_OBSERVATION_CONTEXT,
-  // Task lifecycle (workhorse)
-  create_task: CREATE_TASK,
-  complete_task: COMPLETE_TASK,
-  update_task: UPDATE_TASK,
-  list_tasks: LIST_TASKS,
-  // Topic lifecycle (init, remote)
-  create_topic: CREATE_TOPIC,
-  list_topics: LIST_TOPICS,
-  get_topic: GET_TOPIC,
-  update_topic: UPDATE_TOPIC,
-  get_topic_tree: GET_TOPIC_TREE,
-  // Coding intelligence (code-grounded knowledge)
-  get_code_context: GET_CODE_CONTEXT,
-  get_change_history: GET_CHANGE_HISTORY,
-  record_attempt: RECORD_ATTEMPT,
-  get_failure_log: GET_FAILURE_LOG,
-  // Graph self-intelligence (coverage, gaps)
-  get_topic_coverage: GET_TOPIC_COVERAGE,
-  get_graph_gaps: GET_GRAPH_GAPS,
-  // Ontology lifecycle (definition CRUD, version management)
-  list_ontologies: LIST_ONTOLOGIES,
-  get_ontology: GET_ONTOLOGY,
-  apply_ontology: APPLY_ONTOLOGY,
-  match_entity_type: MATCH_ENTITY_TYPE,
-  create_ontology: CREATE_ONTOLOGY,
-  update_ontology: UPDATE_ONTOLOGY,
-  archive_ontology: ARCHIVE_ONTOLOGY,
-  create_ontology_version: CREATE_ONTOLOGY_VERSION,
-  publish_ontology_version: PUBLISH_ONTOLOGY_VERSION,
-  deprecate_ontology_version: DEPRECATE_ONTOLOGY_VERSION,
-  resolve_effective_ontology: RESOLVE_EFFECTIVE_ONTOLOGY
-};
-var GIT_SEMANTIC_REQUIRED_TOOLS = Object.keys(MCP_TOOL_CONTRACTS);
-function validateGitSemantics(tool) {
-  const desc = tool.description;
-  const hasGitReference = /Like (`git |a `git |a merge conflict|opening a `git)/.test(desc);
-  if (!hasGitReference) {
-    return {
-      valid: false,
-      reason: `Tool "${tool.name}" description missing git-semantic reference`
-    };
-  }
-  return { valid: true };
-}
+// src/contracts/mcpTools.ts
+var mcpTools_exports = {};
+
+// src/contracts/tool-contracts.ts
+var tool_contracts_exports = {};
+__reExport(tool_contracts_exports, tool_contracts_star);
+
+// src/contracts/mcpTools.ts
+__reExport(mcpTools_exports, tool_contracts_exports);
+
+// src/index.ts
+__reExport(src_exports, mcpTools_exports);
 
 // src/contracts/prompt.contract.ts
 function isLucernPrompt(value) {
@@ -11020,6 +8878,8 @@ var DOMAIN_EVENT_TYPES = [
   "identity.key_revoked",
   "webhook.test"
 ];
+var RUNTIME_BUFFER = globalThis.Buffer;
+var RUNTIME_ENV = globalThis.process?.env;
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -11044,14 +8904,14 @@ function matchesAnyEventPattern(eventType, patterns) {
   return patterns.some((pattern) => matchesEventPattern(eventType, pattern));
 }
 function toBase64(value) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(value, "utf8").toString("base64url");
+  if (RUNTIME_BUFFER) {
+    return RUNTIME_BUFFER.from(value, "utf8").toString("base64url");
   }
   return btoa(unescape(encodeURIComponent(value))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
 function fromBase64(value) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(value, "base64url").toString("utf8");
+  if (RUNTIME_BUFFER) {
+    return RUNTIME_BUFFER.from(value, "base64url").toString("utf8");
   }
   const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
   return decodeURIComponent(escape(atob(normalized)));
@@ -11147,7 +9007,7 @@ function normalizeUrl(url) {
 function assertValidWebhookUrl(url) {
   const parsed = normalizeUrl(url);
   const hostname = parsed.hostname.trim().toLowerCase();
-  const nodeEnv = typeof process !== "undefined" ? process.env?.NODE_ENV : void 0;
+  const nodeEnv = RUNTIME_ENV?.NODE_ENV;
   const allowLocalHttp = nodeEnv === "test" || LOCALHOST_HOSTS.has(hostname);
   if (parsed.protocol !== "https:" && !(allowLocalHttp && parsed.protocol === "http:")) {
     throw new Error("Webhook URL must use HTTPS.");
@@ -11314,68 +9174,6 @@ function createWebhooksClientCore(config = {}) {
   };
 }
 
-// src/mcpParitySurface.ts
-var 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" }
-];
-var SDK_MCP_PARITY_METHOD_PATHS = SDK_MCP_PARITY_METHODS.map(
-  (entry) => entry.methodPath
-);
-var SDK_MCP_PARITY_TOOL_NAMES = SDK_MCP_PARITY_METHODS.map(
-  (entry) => entry.toolName
-);
-
-export { ACTIVATE_WORKTREE, ADD_EVIDENCE, ADD_WORKTREE, ANSWER_QUESTION, APPLY_LENS_TO_TOPIC, APPLY_ONTOLOGY, ARCHIVE_BELIEF, ARCHIVE_ONTOLOGY, ARCHIVE_QUESTION, BELIEF_STATUSES, BISECT_CONFIDENCE, BRANCH_DEPRECATION_MESSAGE, CANONICAL_WORKFLOW_DEFINITIONS, CHECK_PERMISSION, COMPILE_CONTEXT, COMPLETE_TASK, CONFIDENCE_TRIGGERS, CONTRADICTION_SEVERITIES, CONTRADICTION_STATUSES, CONTROL_OBJECT_BLAST_RADII, CONTROL_OBJECT_EDIT_SURFACES, CONTROL_OBJECT_INHERITANCE_RULES, CONTROL_OBJECT_KINDS, CONTROL_OBJECT_OWNERSHIP_CONTRACT, CONTROL_OBJECT_OWNERSHIP_MATRIX, CONTROL_OBJECT_OWNERSHIP_ROWS, CONTROL_OBJECT_OWNER_SCOPES, CREATE_ANSWER, CREATE_BELIEF, CREATE_EDGE, CREATE_EPISTEMIC_CONTRACT, CREATE_EVIDENCE, CREATE_LENS, CREATE_ONTOLOGY, CREATE_ONTOLOGY_VERSION, CREATE_QUESTION, CREATE_TASK, CREATE_TOPIC, CustomToolRegistryError, DEFAULT_TIER_APPROVAL_MODE, DEFAULT_WORKFLOW_AUTO_FIX_POLICY, DEFEAT_TYPES, DEPRECATE_ONTOLOGY_VERSION, DETECT_CONFIRMATION_BIAS, DOMAIN_EVENT_TYPES, DOMAIN_EVENT_VERSION, EDGE_TYPES, EPISTEMIC_EDGE_TYPES, EPISTEMIC_LAYERS, EVENT_RETENTION_DEFAULT_DAYS, EXECUTE_DEEP_RESEARCH, FILTER_BY_PERMISSION, FIND_CONTRADICTIONS, FIND_MISSING_QUESTIONS, FLAG_CONTRADICTION, FORK_BELIEF, FORK_REASONS, GET_ANSWER, GET_AUDIT_TRAIL, GET_BELIEF, GET_CHANGE_HISTORY, GET_CODE_CONTEXT, GET_CONFIDENCE_HISTORY, GET_EVIDENCE, GET_FAILURE_LOG, GET_FALSIFICATION_QUESTIONS, GET_GRAPH_GAPS, GET_GRAPH_NEIGHBORHOOD, GET_GRAPH_STRUCTURE_ANALYSIS, GET_HIGH_PRIORITY_QUESTIONS, GET_OBSERVATION_CONTEXT, GET_ONTOLOGY, GET_QUESTION, GET_TOPIC, GET_TOPIC_COVERAGE, GET_TOPIC_TREE, GIT_SEMANTIC_REQUIRED_TOOLS, IDENTITY_WHOAMI, INGEST_OBSERVATION, JUDGMENT_TYPES, LENS_PERSPECTIVE_TYPES, LENS_STATUSES, LENS_TASK_TEMPLATE_PRIORITIES, LINK_EVIDENCE, LINK_EVIDENCE_TO_BELIEF, LINK_EVIDENCE_TO_QUESTION, LIST_ALL_WORKTREES, LIST_BELIEFS, LIST_EVIDENCE, LIST_LENSES, LIST_ONTOLOGIES, LIST_QUESTIONS, LIST_TASKS, LIST_TOPICS, LIST_WORKTREES, LUCERN_SDK_VERSION, LucernApiError, MANAGE_WRITE_POLICY, MATCH_ENTITY_TYPE, MAX_ENTITY_LIMIT, MCP_TOOL_CONTRACTS, MERGE, MERGE_OUTCOMES, MODULATE_CONFIDENCE, MORNING_BRIEF_WORKFLOW_ID, NIGHTLY_RECONCILIATION_WORKFLOW_ID, OPEN_PULL_REQUEST, PUBLISH_ONTOLOGY_VERSION, PUSH, QUERY_LINEAGE, REASONING_METHODS, RECORD_ATTEMPT, RECORD_JUDGMENT, REFINE_BELIEF, REFINE_QUESTION, REMOVE_LENS_FROM_TOPIC, RESOLVE_EFFECTIVE_ONTOLOGY, SDK_MCP_PARITY_METHODS, SDK_MCP_PARITY_METHOD_PATHS, SDK_MCP_PARITY_TOOL_NAMES, SEARCH_BELIEFS, SEARCH_EVIDENCE, SEARCH_RESOURCES, SEARCH_SOURCES, SESSION_AUTH_MODES, SESSION_LIFECYCLE_STATUSES, SESSION_PRINCIPAL_TYPES, STRUCTURAL_EDGE_TYPES, TRACE_ENTITY_IMPACT, TRAVERSE_GRAPH, UPDATE_ONTOLOGY, UPDATE_QUESTION_STATUS, UPDATE_TASK, UPDATE_TOPIC, UPDATE_WORKTREE_METADATA, UPDATE_WORKTREE_TARGETS, WEBHOOK_MAX_ATTEMPTS, WEBHOOK_RETRY_DELAYS_MS, WORKFLOW_ACTION_KINDS, WORKFLOW_APPROVAL_MODES, WORKFLOW_AUTO_FIX_MODES, WORKFLOW_HOOK_EVENTS, WORKFLOW_INTEGRITY_CHECKS, WORKFLOW_MUTATION_TIERS, WORKFLOW_OUTPUT_KINDS, WORKFLOW_PROOF_ARTIFACT_KINDS, WORKFLOW_RUNTIME_SCHEMA_VERSION, WORKFLOW_RUN_STATUSES, WORKFLOW_STAFFING_HINTS, WORKFLOW_TRIGGER_KINDS, WORKTREE_PHASES, asListItems, assertValidWebhookSecret, assertValidWebhookUrl, buildDeprecatedBranchMetadata, buildDomainEvent, clearRegisteredCustomTools, compareEventCursor, compileContextPackFromSnapshot, computeWebhookSignature, createAdminClient, createAnswersClient, createAudiencesClient, createAuditClient, createBeliefsClient, createContextClient, createContextFacade, createDecisionsClient, createEventId, createEventsClientCore, createGatewayRequestClient, createGraphClient, createHarnessClient, createIdentityClient, createLearningClient, createListResult, createLucernClient, createMcpParityClient, createOntologyClient, createPacksClient, createPolicyClient, createReportsClient, createSchemaClient, createTopicsClient, createWebhooksClientCore, createWorkflowClient, decodeEventCursor, emitDomainEvent, encodeEventCursor, eventPatternToRegExp, getControlObjectOwnershipCase, getRegisteredCustomTool, inferActorType, inferLensPerspectiveTypeFromBranchSchema, inferSessionPrincipalType, invokeRegisteredCustomTool, isAfterCursor, isLensFilterCriteria, isLucernPrompt, isTaxonomyFilterCriteriaV1, lastDelegator, listControlObjectOwnershipCases, listRegisteredCustomTools, mapAliasedList, mapGatewayData, matchesAnyEventPattern, matchesEventPattern, migrateBranchToLens, nextDeliveryAttemptAt, normalizeDelegationChain, normalizeNodeVerificationStatus, normalizeNodeWriteInput, normalizeRetentionDays, normalizeTopicQuery, normalizeWebhookPatterns, planContextPackCompilation, randomIdempotencyKey, registerCustomTool, resolveDeliveryFailureStatus, resolveText, resolveTopicId, sanitizeWebhookRecord, sortEventsByCursor, toQueryString, truncateWebhookResponseBody, unregisterCustomTool, validateFilterCriteria, validateGitSemantics, withSdkAliases, withTextAlias, withTopicAlias };
+export { BELIEF_STATUSES, BRANCH_DEPRECATION_MESSAGE, CANONICAL_WORKFLOW_DEFINITIONS, CONFIDENCE_TRIGGERS, CONTRADICTION_SEVERITIES, CONTRADICTION_STATUSES, CONTROL_OBJECT_BLAST_RADII, CONTROL_OBJECT_EDIT_SURFACES, CONTROL_OBJECT_INHERITANCE_RULES, CONTROL_OBJECT_KINDS, CONTROL_OBJECT_OWNERSHIP_CONTRACT, CONTROL_OBJECT_OWNERSHIP_MATRIX, CONTROL_OBJECT_OWNERSHIP_ROWS, CONTROL_OBJECT_OWNER_SCOPES, CustomToolRegistryError, DEFAULT_TIER_APPROVAL_MODE, DEFAULT_WORKFLOW_AUTO_FIX_POLICY, DEFEAT_TYPES, DOMAIN_EVENT_TYPES, DOMAIN_EVENT_VERSION, EDGE_TYPES, EPISTEMIC_EDGE_TYPES, EPISTEMIC_LAYERS, EVENT_RETENTION_DEFAULT_DAYS, FORK_REASONS, FUNCTION_SURFACE_METHOD_PATHS, JUDGMENT_TYPES, LENS_PERSPECTIVE_TYPES, LENS_STATUSES, LENS_TASK_TEMPLATE_PRIORITIES, LUCERN_SDK_VERSION, LucernApiError, MAX_ENTITY_LIMIT, MERGE_OUTCOMES, MORNING_BRIEF_WORKFLOW_ID, NIGHTLY_RECONCILIATION_WORKFLOW_ID, REASONING_METHODS, SESSION_AUTH_MODES, SESSION_LIFECYCLE_STATUSES, SESSION_PRINCIPAL_TYPES, STRUCTURAL_EDGE_TYPES, WEBHOOK_MAX_ATTEMPTS, WEBHOOK_RETRY_DELAYS_MS, WORKFLOW_ACTION_KINDS, WORKFLOW_APPROVAL_MODES, WORKFLOW_AUTO_FIX_MODES, WORKFLOW_HOOK_EVENTS, WORKFLOW_INTEGRITY_CHECKS, WORKFLOW_MUTATION_TIERS, WORKFLOW_OUTPUT_KINDS, WORKFLOW_PROOF_ARTIFACT_KINDS, WORKFLOW_RUNTIME_SCHEMA_VERSION, WORKFLOW_RUN_STATUSES, WORKFLOW_STAFFING_HINTS, WORKFLOW_TRIGGER_KINDS, WORKTREE_PHASES, asListItems, assertValidWebhookSecret, assertValidWebhookUrl, buildDeprecatedBranchMetadata, buildDomainEvent, clearRegisteredCustomTools, compareEventCursor, compileContextPackFromSnapshot, computeWebhookSignature, createAdminClient, createAnswersClient, createAudiencesClient, createAuditClient, createBeliefsClient, createContextClient, createContextFacade, createDecisionsClient, createEventId, createEventsClientCore, createEvidenceClient, createFunctionSurfaceClient, createGatewayRequestClient, createGraphClient, createHarnessClient, createIdentityClient, createLearningClient, createListResult, createLucernClient, createOntologyClient, createPacksClient, createPolicyClient, createReportsClient, createSchemaClient, createSourcesClient, createTopicsClient, createWebhooksClientCore, createWorkflowClient, decodeEventCursor, emitDomainEvent, encodeEventCursor, eventPatternToRegExp, getControlObjectOwnershipCase, getRegisteredCustomTool, inferActorType, inferLensPerspectiveTypeFromBranchSchema, inferSessionPrincipalType, invokeRegisteredCustomTool, isAfterCursor, isLensFilterCriteria, isLucernPrompt, isTaxonomyFilterCriteriaV1, lastDelegator, listControlObjectOwnershipCases, listRegisteredCustomTools, mapAliasedList, mapGatewayData, mapOpinionHistoryEntriesFromGatewayData, matchesAnyEventPattern, matchesEventPattern, migrateBranchToLens, nextDeliveryAttemptAt, normalizeDelegationChain, normalizeNodeVerificationStatus, normalizeNodeWriteInput, normalizeRetentionDays, normalizeTopicQuery, normalizeWebhookPatterns, opinionFromBaseRate, opinionFromDogmatic, opinionFromProjected, planContextPackCompilation, randomIdempotencyKey, registerCustomTool, resolveDeliveryFailureStatus, resolveText, resolveTopicId, sanitizeWebhookRecord, sortEventsByCursor, toQueryString, truncateWebhookResponseBody, unregisterCustomTool, validateFilterCriteria, withSdkAliases, withTextAlias, withTopicAlias };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map