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

package/dist/client.js

@@ -997,32 +997,201 @@ function createAuditClient(config = {}) {
   };
 }
 
+// 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/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 +1282,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 +2122,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 +2154,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 +2171,7 @@ function createTopicsClient(config = {}) {
       }).then(
         (response) => mapGatewayData(
           response,
-          (data) => normalizeTopicRecord(asRecord2(data).topic ?? data)
+          (data) => normalizeTopicRecord(asRecord3(data).topic ?? data)
         )
       );
     },
@@ -1987,7 +2207,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 +2241,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 +2308,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 +2386,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 +3611,479 @@ function createLearningClient(config = {}) {
   };
 }
 
-// src/mcpParityClient.ts
-function withSdkSessionId(args, sessionId) {
+// src/generated/functionSurface.ts
+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);
+    },
+    manageWritePolicy(input = {}, idempotencyKey) {
+      return execute("manage_write_policy", input, idempotencyKey);
+    },
+    matchEntityType(input = {}, idempotencyKey) {
+      return execute("match_entity_type", input, idempotencyKey);
+    },
+    merge(input = {}, idempotencyKey) {
+      return execute("merge", input, idempotencyKey);
+    },
+    modulateConfidence(input = {}, idempotencyKey) {
+      return execute("modulate_confidence", input, idempotencyKey);
+    },
+    openPullRequest(input = {}, idempotencyKey) {
+      return execute("open_pull_request", input, idempotencyKey);
+    },
+    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);
     },
-    evaluateContract(args, idempotencyKey) {
-      return executeMutation("evaluate_contract", args, idempotencyKey);
+    searchBeliefs(input = {}, idempotencyKey) {
+      return execute("search_beliefs", input, idempotencyKey);
     },
-    getContractStatus(args) {
-      return executeRead("get_contract_status", args);
+    searchEvidence(input = {}, idempotencyKey) {
+      return execute("search_evidence", input, idempotencyKey);
     },
-    checkPermission(args) {
-      return executeRead("check_permission", args);
+    seedBeliefLattice(input = {}, idempotencyKey) {
+      return execute("seed_belief_lattice", input, idempotencyKey);
     },
-    filterByPermission(args) {
-      return executeRead("filter_by_permission", args);
+    sendAgentMessage(input = {}, idempotencyKey) {
+      return execute("send_agent_message", input, idempotencyKey);
     },
-    manageWritePolicy(args, idempotencyKey) {
-      return args.action === "set" ? executeMutation("manage_write_policy", args, idempotencyKey) : executeRead("manage_write_policy", args);
+    traceEntityImpact(input = {}, idempotencyKey) {
+      return execute("trace_entity_impact", input, idempotencyKey);
     },
-    generateSessionHandoff(args) {
-      return executeRead("generate_session_handoff", args);
+    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 +5150,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 +5191,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 +5271,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 +5280,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 +5407,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 +5591,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 +5670,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 +5804,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 +5826,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 +5870,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 +5971,7 @@ function createLucernClient(config = {}) {
       },
       queryLineage,
       getConfidenceHistory,
+      getOpinionHistory,
       getAuditTrail,
       traverse(args) {
         return graphFacade.traverse({
@@ -5634,7 +6200,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 +6236,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 +6267,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 +6400,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 +6446,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);
+      },
+      getAgentInbox(input = {}) {
+        return functionSurfaceClient.getAgentInbox(input);
       },
-      claimFiles(input) {
-        return mcpParityClient.claimFiles(input);
+      claimFiles(input, idempotencyKey) {
+        return functionSurfaceClient.claimFiles(input, idempotencyKey);
       }
     },
     policy: {
@@ -5943,107 +6521,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 +6644,8 @@ function createLucernClient(config = {}) {
     extensions: extensionNamespaces,
     raw: {
       beliefs: beliefsClient,
+      sources: sourcesClient,
+      evidence: evidenceClient,
       graph: graphClient,
       decisions: decisionsClient,
       workflow: workflowClient,
@@ -6117,7 +6655,7 @@ function createLucernClient(config = {}) {
       policy: policyClient,
       answers: answersClient,
       ontology: ontologyClient,
-      mcpParity: mcpParityClient,
+      functionSurface: functionSurfaceClient,
       packs: packsClient,
       reports: reportsClient,
       learning: learningClient,