@lucern/contracts 0.1.2-alpha.4 → 0.3.0-alpha.0

package/dist/function-registry/helpers.js

@@ -0,0 +1,4131 @@
+import { z } from 'zod';
+
+// src/function-registry/helpers.ts
+
+// src/lens-workflow.contract.ts
+var LENS_PERSPECTIVE_TYPES = [
+  "investigation",
+  "monitoring",
+  "analysis",
+  "comparison",
+  "taxonomy"
+];
+
+// src/tool-contracts.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 with a mandatory prior. Creation stores the vacuous opinion `(0, 0, 1, a)`; use modulate_confidence to record the first evidential update.",
+  parameters: {
+    canonicalText: {
+      type: "string",
+      description: "The belief statement \u2014 what the agent holds to be true"
+    },
+    topicId: {
+      type: "string",
+      description: "Optional topic scope hint for the belief"
+    },
+    baseRate: {
+      type: "number",
+      description: "Required prior probability used to seed the vacuous opinion `(0, 0, 1, a)` at creation time."
+    },
+    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", "baseRate"],
+  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. Pass the full subjective-logic tuple (`belief`, `disbelief`, `uncertainty`, `baseRate`) directly. If a caller only has a scalar probability, use `@lucern/sdk` helpers `opinionFromBaseRate`, `opinionFromDogmatic`, or `opinionFromProjected` to name the intended interpretation before calling this tool. Triggers: evidence_added, evidence_removed, contradiction_detected, contradiction_resolved, agent_assessment, worktree_outcome, worktree_completed, fusion, discount, deduction, manual, decay.",
+  parameters: {
+    nodeId: { type: "string", description: "The belief to score" },
+    belief: {
+      type: "number",
+      description: "Subjective-logic belief mass `b` in [0, 1]"
+    },
+    disbelief: {
+      type: "number",
+      description: "Subjective-logic disbelief mass `d` in [0, 1]"
+    },
+    uncertainty: {
+      type: "number",
+      description: "Subjective-logic uncertainty mass `u` in [0, 1]"
+    },
+    baseRate: {
+      type: "number",
+      description: "Subjective-logic base rate `a` in [0, 1]. Required for tuple payloads."
+    },
+    confidence: {
+      type: "number",
+      description: "Deprecated scalar confidence value in [0, 1]. Scalar-only payloads are rejected as AMBIGUOUS_SCALAR."
+    },
+    trigger: {
+      type: "string",
+      description: "What caused this confidence change",
+      enum: [
+        "evidence_added",
+        "evidence_removed",
+        "contradiction_detected",
+        "contradiction_resolved",
+        "agent_assessment",
+        "worktree_outcome",
+        "worktree_completed",
+        "fusion",
+        "discount",
+        "deduction",
+        "manual",
+        "decay"
+      ]
+    },
+    rationale: {
+      type: "string",
+      description: "Human-readable explanation of why confidence changed"
+    }
+  },
+  required: ["nodeId", "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: "Optional topic scope hint" },
+    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", "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: "Optional topic scope hint" },
+    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"],
+  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: "Optional topic scope hint" },
+    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 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"],
+  response: {
+    description: "The recorded judgment",
+    fields: {
+      judgmentId: "string",
+      title: "string",
+      status: "string \u2014 'issued'"
+    }
+  },
+  ownerModule: "decisions",
+  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: "reasoning-kernel",
+  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: "reasoning-kernel",
+  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: "reasoning-kernel",
+  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: "reasoning-kernel",
+  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_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: ["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: "Optional topic scope hint" },
+    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"],
+  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: "Optional topic scope hint 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: ["observationType", "summary"],
+  response: {
+    description: "Recorded observation entry",
+    fields: {
+      observationId: "string",
+      topicId: "string",
+      observationType: "string",
+      createdAt: "number",
+      contextResourceUri: "string"
+    }
+  },
+  ownerModule: "agent-frameworks",
+  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: "Optional topic scope hint" },
+    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-frameworks",
+  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"],
+  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: "reasoning-kernel",
+  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: "reasoning-kernel",
+  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: "reasoning-kernel",
+  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: "reasoning-kernel",
+  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: "reasoning-kernel",
+  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: "reasoning-kernel",
+  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: "reasoning-kernel",
+  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 RECORD_SCOPE_LEARNING = {
+  name: "record_scope_learning",
+  description: "Write a structured learning entry into the epistemic spine. Like `git commit` for scope learnings \u2014 records evidence, can attach to a belief, and can open a follow-up belief/question in one atomic workflow.",
+  parameters: {
+    topicId: { type: "string", description: "Topic scope ID" },
+    summary: { type: "string", description: "Atomic learning statement" },
+    title: {
+      type: "string",
+      description: "Optional evidence title, such as a commit, doc, or issue."
+    },
+    body: {
+      type: "string",
+      description: "Optional rich evidence body. If omitted, body is synthesized from summary and touched paths."
+    },
+    contentType: {
+      type: "string",
+      description: "Optional evidence body format, such as markdown or text."
+    },
+    sourceKind: {
+      type: "string",
+      description: "Source type for the learning event",
+      enum: ["commit", "merge", "doc", "issue", "manual"]
+    },
+    sourceRef: {
+      type: "string",
+      description: "Optional source reference, such as SHA, PR number, or URL slug."
+    },
+    sourceUrl: { type: "string", description: "Optional canonical source URL" },
+    touchedPaths: {
+      type: "array",
+      description: "Optional touched file paths for retrieval hints"
+    },
+    tags: { type: "array", description: "Optional tags" },
+    linkedBeliefNodeId: {
+      type: "string",
+      description: "Optional belief to attach evidence to"
+    },
+    evidenceRelation: {
+      type: "string",
+      description: "Relation to linked belief",
+      enum: ["supports", "contradicts"]
+    },
+    confidence: { type: "number", description: "Optional confidence in [0,1]" },
+    createQuestionText: {
+      type: "string",
+      description: "Optional follow-up question text"
+    },
+    createBeliefText: {
+      type: "string",
+      description: "Optional new belief text"
+    },
+    beliefType: {
+      type: "string",
+      description: "Optional belief type for createBeliefText"
+    }
+  },
+  required: ["summary"],
+  response: {
+    description: "Created learning artifacts",
+    fields: {
+      topicId: "string \u2014 resolved topic ID",
+      evidenceNodeId: "string",
+      linkedBeliefNodeId: "string | null",
+      createdQuestionId: "string | null",
+      createdBeliefId: "string | null",
+      sourceUrl: "string",
+      createdAt: "number"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "evidence",
+  tier: "workhorse",
+  internal: true
+};
+var PIPELINE_SNAPSHOT = {
+  name: "pipeline_snapshot",
+  description: "Summarize a topic's worktree pipeline in band-and-lane form. Like `git status --short` for Lucern execution \u2014 returns the hinge worktree, next planned wave, blockers, critical path, superseded work, and graph hygiene debt.",
+  parameters: {
+    topicId: { type: "string", description: "Topic scope ID" }
+  },
+  required: ["topicId"],
+  response: {
+    description: "Human-oriented pipeline summary for a single topic scope",
+    fields: {
+      topicId: "string",
+      topicName: "string",
+      currentBand: "number | null",
+      nextBand: "number | null",
+      activeWorktrees: "array \u2014 current hinge worktree(s)",
+      nextWave: "array \u2014 worktrees in the next planned band",
+      readyNow: "array \u2014 planning worktrees with dependencies completed",
+      blockedBy: "array \u2014 grouped blockers",
+      criticalPath: "array \u2014 ordered incomplete worktree chain",
+      bands: "array \u2014 incomplete worktrees grouped by executionBand",
+      superseded: "array \u2014 worktrees marked superseded or not for activation",
+      graphHygiene: "object \u2014 untargeted and taskless worktree debt",
+      riskQuestions: "array \u2014 critical/high open questions",
+      narrative: "array \u2014 concise natural-language summary lines"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse",
+  internal: true
+};
+var DISCOVER = {
+  name: "discover",
+  description: "Navigate the topic tree to find where knowledge lives. Like `git log --all --grep` \u2014 searches across the graph using bottom-up content matching plus top-down structural scoring.",
+  parameters: {
+    query: {
+      type: "string",
+      description: "What to look for across the topic tree"
+    },
+    topK: {
+      type: "number",
+      description: "How many matching topics to return (default: 3, max: 10)"
+    },
+    includeNeighborhood: {
+      type: "boolean",
+      description: "Whether to include beliefs/questions/evidence for matched topics"
+    }
+  },
+  required: ["query"],
+  response: {
+    description: "Ranked topic matches with optional neighborhood content",
+    fields: {
+      query: "string \u2014 original query",
+      matchedTopics: "array \u2014 ranked topics with scores and paths",
+      neighborhoods: "array \u2014 beliefs, questions, evidence for each match",
+      totalTopicsScored: "number",
+      topicTreeSize: "number"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "showcase",
+  deprecated: "Deprecated: use lucern.context.compile() with topicId"
+};
+var ANALYZE_TOPIC_DENSITY = {
+  name: "analyze_topic_density",
+  description: "Analyze topic belief density and identify natural conceptual clusters. Like `git diff --stat` for topic organization \u2014 detects when a topic has accumulated too many beliefs and suggests subtopic decomposition.",
+  parameters: {
+    topicId: { type: "string", description: "Topic ID to analyze" },
+    threshold: {
+      type: "number",
+      description: "Belief count threshold for density warning"
+    },
+    minModularity: {
+      type: "number",
+      description: "Minimum modularity score for suggesting decomposition"
+    }
+  },
+  required: ["topicId"],
+  response: {
+    description: "Density analysis with cluster suggestions",
+    fields: {
+      topicId: "string",
+      topicName: "string",
+      beliefCount: "number",
+      edgeCount: "number",
+      threshold: "number",
+      isDense: "boolean",
+      modularity: "number",
+      clusterCount: "number",
+      clusters: "array \u2014 suggested belief clusters",
+      recommendation: "string"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "showcase"
+};
+var APPLY_AUTO_BRANCHING = {
+  name: "apply_auto_branching",
+  description: "Execute topic decomposition by creating subtopics and reassigning beliefs. Like `git subtree split` \u2014 splits a dense topic into focused subtopics while preserving belief identity and edges.",
+  parameters: {
+    topicId: { type: "string", description: "Parent topic ID to decompose" },
+    clusters: {
+      type: "array",
+      description: "Cluster definitions from analyze_topic_density, each with name and beliefIds"
+    },
+    dryRun: {
+      type: "boolean",
+      description: "Preview changes without applying them"
+    }
+  },
+  required: ["topicId", "clusters"],
+  response: {
+    description: "Results of the auto-branching operation",
+    fields: {
+      success: "boolean",
+      parentTopicId: "string",
+      createdSubtopics: "array",
+      totalReassigned: "number",
+      totalSkipped: "number",
+      dryRun: "boolean"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "showcase"
+};
+var SEED_BELIEF_LATTICE = {
+  name: "seed_belief_lattice",
+  description: "Seed belief lattice coverage for a topic based on its resolved ontology. Like `git init` for ontology coverage \u2014 creates or previews seed beliefs for entity types that need a baseline anchor.",
+  parameters: {
+    topicId: {
+      type: "string",
+      description: "Topic scope ID. Lattice seeding must target a child topic."
+    },
+    dryRun: {
+      type: "boolean",
+      description: "Preview seeds without creating them"
+    }
+  },
+  required: [],
+  response: {
+    description: "Lattice seed results with per-entity-type status",
+    fields: {
+      topicId: "string",
+      ontologyResolved: "boolean",
+      ontologyKey: "string | null",
+      ontologyVersion: "string | null",
+      entityTypeCount: "number",
+      seeds: "array \u2014 per-entity-type seed status",
+      summary: "object \u2014 created/existing/scored/total counts",
+      dryRun: "boolean"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "belief",
+  tier: "workhorse",
+  internal: true
+};
+var GET_LATTICE_COVERAGE = {
+  name: "get_lattice_coverage",
+  description: "Report belief lattice coverage for a topic. Like `git fsck` for ontology coverage \u2014 identifies anchored, hollow, and missing entity-type belief coverage.",
+  parameters: {
+    topicId: {
+      type: "string",
+      description: "Topic scope ID to check lattice coverage for"
+    }
+  },
+  required: [],
+  response: {
+    description: "Per-entity-type coverage with overall score",
+    fields: {
+      topicId: "string",
+      ontologyKey: "string | null",
+      ontologyVersion: "string | null",
+      entityTypes: "array \u2014 per-entity-type coverage rows",
+      summary: "object \u2014 total/anchored/hollow/missing/coverageScore"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "belief",
+  tier: "workhorse",
+  internal: true
+};
+var DISCOVER_ENTITY_CONNECTIONS = {
+  name: "discover_entity_connections",
+  description: "Find existing entities that should be connected to a belief/question/evidence node. Like `git log --diff-filter=M` for missing entity connections \u2014 scans entities in scope and suggests bridge edge types.",
+  parameters: {
+    nodeId: {
+      type: "string",
+      description: "Epistemic node ID to find entity connections for"
+    },
+    topicId: {
+      type: "string",
+      description: "Optional topic scope override"
+    },
+    minScore: {
+      type: "number",
+      description: "Minimum match score threshold"
+    },
+    limit: {
+      type: "number",
+      description: "Maximum candidates to return"
+    }
+  },
+  required: ["nodeId"],
+  response: {
+    description: "Ranked entity connection candidates",
+    fields: {
+      nodeId: "string",
+      candidateCount: "number",
+      candidates: "array \u2014 suggested entity bridge candidates"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "ontology",
+  tier: "workhorse"
+};
+var TRIGGER_BELIEF_REVIEW = {
+  name: "trigger_belief_review",
+  description: "Flag beliefs for review after an entity changes. Like `git bisect` for stale beliefs \u2014 traverses bridge edges from the changed entity and creates review questions for stale connected beliefs.",
+  parameters: {
+    entityNodeId: {
+      type: "string",
+      description: "The entity node that changed"
+    },
+    changeDescription: {
+      type: "string",
+      description: "What changed about the entity"
+    },
+    maxQuestions: {
+      type: "number",
+      description: "Maximum review questions to create"
+    }
+  },
+  required: ["entityNodeId"],
+  response: {
+    description: "Affected beliefs and created review questions",
+    fields: {
+      entityNodeId: "string",
+      entityTitle: "string",
+      entityType: "string",
+      changeDescription: "string",
+      affectedBeliefCount: "number",
+      questionsCreated: "number",
+      reviewedBeliefs: "array",
+      questions: "array"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "ontology",
+  tier: "workhorse"
+};
+var EVALUATE_CONTRACT = {
+  name: "evaluate_contract",
+  description: "Run a contract evaluation and record the append-only result. Like `git test` for a belief binding \u2014 executes the evaluator, logs the result, and applies any allowed confidence modulation.",
+  parameters: {
+    contractId: { type: "string", description: "Which contract to evaluate" },
+    trigger: {
+      type: "string",
+      description: "What caused this evaluation"
+    }
+  },
+  required: ["contractId"],
+  response: {
+    description: "The most recent contract evaluation result",
+    fields: {
+      evaluationId: "string",
+      result: "string",
+      status: "string",
+      confidenceBefore: "number",
+      confidenceAfter: "number",
+      rationale: "string"
+    }
+  },
+  ownerModule: "graph-primitives",
+  ontologyPrimitive: "belief",
+  tier: "workhorse"
+};
+var GET_CONTRACT_STATUS = {
+  name: "get_contract_status",
+  description: "Inspect epistemic contracts and their latest evaluations. Like `git status` for verification bindings \u2014 returns the contract rows plus the freshest recorded evaluation for each one.",
+  parameters: {
+    beliefNodeId: {
+      type: "string",
+      description: "Return all contracts attached to a specific belief"
+    },
+    contractId: {
+      type: "string",
+      description: "Return one specific contract by contractId"
+    },
+    status: {
+      type: "string",
+      description: "Optional status filter applied after lookup",
+      enum: ["active", "satisfied", "violated", "expired", "suspended", "archived"]
+    }
+  },
+  required: [],
+  response: {
+    description: "Matching contract rows with latest evaluation context",
+    fields: {
+      contracts: "array \u2014 matching contracts with latestEvaluation attached",
+      count: "number"
+    }
+  },
+  ownerModule: "graph-primitives",
+  ontologyPrimitive: "belief",
+  tier: "workhorse"
+};
+var REGISTER_SESSION = {
+  name: "register_session",
+  description: "Announce this agent session's presence to other parallel sessions. Like `git init` for coordination \u2014 creates a session record so other agents can discover you.",
+  parameters: {
+    sessionName: { type: "string", description: "Human-readable session label" },
+    agentType: { type: "string", description: "Agent type" },
+    topicId: { type: "string", description: "Current Lucern topic scope ID" },
+    worktreeId: { type: "string", description: "Active Lucern worktree ID" },
+    gitBranch: { type: "string", description: "Current git branch name" }
+  },
+  required: [],
+  response: {
+    description: "Session registration result",
+    fields: {
+      sessionId: "string",
+      status: "string \u2014 active",
+      isNew: "boolean"
+    }
+  },
+  ownerModule: "coordination",
+  ontologyPrimitive: "graph",
+  tier: "workhorse",
+  internal: true
+};
+var HEARTBEAT_SESSION = {
+  name: "heartbeat_session",
+  description: "Update this session's heartbeat and optional status fields. Like `git status` \u2014 signals liveness and updates what you are working on.",
+  parameters: {
+    topicId: { type: "string", description: "Updated topic scope" },
+    worktreeId: { type: "string", description: "Updated worktree ID" },
+    gitBranch: { type: "string", description: "Updated git branch" },
+    status: {
+      type: "string",
+      description: "Session status update",
+      enum: ["active", "idle"]
+    }
+  },
+  required: [],
+  response: {
+    description: "Heartbeat result",
+    fields: {
+      success: "boolean",
+      message: "string"
+    }
+  },
+  ownerModule: "coordination",
+  ontologyPrimitive: "graph",
+  tier: "workhorse",
+  internal: true
+};
+var END_SESSION = {
+  name: "end_session",
+  description: "Gracefully end this agent session. Like `git stash` \u2014 marks the session as ended so other agents know you are gone.",
+  parameters: {},
+  required: [],
+  response: {
+    description: "Session end result",
+    fields: {
+      success: "boolean",
+      message: "string"
+    }
+  },
+  ownerModule: "coordination",
+  ontologyPrimitive: "graph",
+  tier: "workhorse",
+  internal: true
+};
+var LIST_ACTIVE_SESSIONS = {
+  name: "list_active_sessions",
+  description: "See who else is online with active agent sessions, scope, branch, and file claims. Like `git branch --list` for live agents \u2014 shows active and idle sessions before editing.",
+  parameters: {
+    includeIdle: {
+      type: "boolean",
+      description: "Include idle sessions"
+    }
+  },
+  required: [],
+  response: {
+    description: "List of active/idle agent sessions",
+    fields: {
+      sessions: "array \u2014 active session records"
+    }
+  },
+  ownerModule: "coordination",
+  ontologyPrimitive: "graph",
+  tier: "workhorse",
+  internal: true
+};
+var SEND_AGENT_MESSAGE = {
+  name: "send_agent_message",
+  description: "Send a directed message to a specific agent session. Like `git notes` \u2014 leaves a coordination note for a specific peer.",
+  parameters: {
+    toSessionId: { type: "string", description: "Target session ID" },
+    content: { type: "string", description: "Message text" },
+    messageType: {
+      type: "string",
+      description: "Message intent",
+      enum: ["note", "question", "answer", "alert", "handoff"]
+    },
+    relatedBeliefId: {
+      type: "string",
+      description: "Optional related belief node ID"
+    },
+    relatedWorktreeId: {
+      type: "string",
+      description: "Optional related worktree ID"
+    }
+  },
+  required: ["toSessionId", "content"],
+  response: {
+    description: "Message delivery result",
+    fields: { messageId: "string" }
+  },
+  ownerModule: "coordination",
+  ontologyPrimitive: "graph",
+  tier: "workhorse",
+  internal: true
+};
+var BROADCAST_MESSAGE = {
+  name: "broadcast_message",
+  description: "Send a message to all active agent sessions. Like `git tag` \u2014 marks an important event visible to everyone.",
+  parameters: {
+    content: { type: "string", description: "Broadcast message text" },
+    messageType: {
+      type: "string",
+      description: "Message intent",
+      enum: ["note", "alert", "handoff"]
+    },
+    relatedBeliefId: {
+      type: "string",
+      description: "Optional related belief node ID"
+    },
+    relatedWorktreeId: {
+      type: "string",
+      description: "Optional related worktree ID"
+    }
+  },
+  required: ["content"],
+  response: {
+    description: "Broadcast result",
+    fields: { messageId: "string" }
+  },
+  ownerModule: "coordination",
+  ontologyPrimitive: "graph",
+  tier: "workhorse",
+  internal: true
+};
+var GET_AGENT_INBOX = {
+  name: "get_agent_inbox",
+  description: "Check unread messages addressed to this session. Like `git log --incoming` \u2014 shows direct and broadcast messages from other agents.",
+  parameters: {
+    limit: { type: "number", description: "Max messages to return" },
+    markAsRead: {
+      type: "boolean",
+      description: "Mark returned messages as read"
+    }
+  },
+  required: [],
+  response: {
+    description: "Inbox messages",
+    fields: {
+      messages: "array \u2014 unread direct and broadcast messages"
+    }
+  },
+  ownerModule: "coordination",
+  ontologyPrimitive: "graph",
+  tier: "workhorse",
+  internal: true
+};
+var CLAIM_FILES = {
+  name: "claim_files",
+  description: "Declare which files this session is actively editing. Like `git add` for coordination \u2014 tells other sessions what you are touching and returns advisory conflicts.",
+  parameters: {
+    files: {
+      type: "array",
+      description: "File paths this session is actively editing"
+    }
+  },
+  required: ["files"],
+  response: {
+    description: "File claim result with conflict detection",
+    fields: {
+      success: "boolean",
+      conflicts: "array \u2014 conflicting file claims"
+    }
+  },
+  ownerModule: "coordination",
+  ontologyPrimitive: "graph",
+  tier: "workhorse",
+  internal: true
+};
+var GENERATE_SESSION_HANDOFF = {
+  name: "generate_session_handoff",
+  description: "Generate a complete, zero-context handoff message for a new coding session. Like `git format-patch` \u2014 produces a self-contained instruction set that bootstraps a fresh Lucern worktree session.",
+  parameters: {
+    worktreeId: {
+      type: "string",
+      description: "The Lucern worktree ID to generate handoff instructions for"
+    },
+    gitWorktreePath: {
+      type: "string",
+      description: "Optional existing git worktree path"
+    },
+    gitBranchName: {
+      type: "string",
+      description: "Optional branch name for the session"
+    },
+    additionalContext: {
+      type: "string",
+      description: "Optional extra context to include in the handoff"
+    }
+  },
+  required: ["worktreeId"],
+  response: {
+    description: "A complete handoff message ready for a new coding session",
+    fields: {
+      handoffMessage: "string",
+      worktreeId: "string",
+      worktreeName: "string",
+      trackBoundary: "object",
+      needsActivation: "boolean",
+      needsGitSetup: "string \u2014 create | fast-forward | ready"
+    }
+  },
+  ownerModule: "bootstrap",
+  ontologyPrimitive: "worktree",
+  tier: "showcase",
+  internal: true
+};
+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,
+  evaluate_contract: EVALUATE_CONTRACT,
+  get_contract_status: GET_CONTRACT_STATUS,
+  // 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,
+  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,
+  // 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,
+  record_scope_learning: RECORD_SCOPE_LEARNING,
+  pipeline_snapshot: PIPELINE_SNAPSHOT,
+  discover: DISCOVER,
+  analyze_topic_density: ANALYZE_TOPIC_DENSITY,
+  apply_auto_branching: APPLY_AUTO_BRANCHING,
+  seed_belief_lattice: SEED_BELIEF_LATTICE,
+  get_lattice_coverage: GET_LATTICE_COVERAGE,
+  discover_entity_connections: DISCOVER_ENTITY_CONNECTIONS,
+  trigger_belief_review: TRIGGER_BELIEF_REVIEW,
+  register_session: REGISTER_SESSION,
+  heartbeat_session: HEARTBEAT_SESSION,
+  end_session: END_SESSION,
+  list_active_sessions: LIST_ACTIVE_SESSIONS,
+  send_agent_message: SEND_AGENT_MESSAGE,
+  broadcast_message: BROADCAST_MESSAGE,
+  get_agent_inbox: GET_AGENT_INBOX,
+  claim_files: CLAIM_FILES,
+  generate_session_handoff: GENERATE_SESSION_HANDOFF,
+  // 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
+};
+
+// src/function-registry/manifest.ts
+var publicEverywhere = {
+  sdk: "public",
+  rest: "public",
+  mcp: "public",
+  cli: "public"
+};
+var internalSystem = {
+  sdk: "internal",
+  rest: "internal",
+  mcp: "internal",
+  cli: "internal"
+};
+var publicWithInternalMcp = {
+  sdk: "public",
+  rest: "public",
+  mcp: "internal",
+  cli: "public"
+};
+var publicWithoutMcp = {
+  sdk: "public",
+  rest: "public",
+  mcp: "none",
+  cli: "none"
+};
+var sdkOnlyPublic = {
+  sdk: "public",
+  rest: "none",
+  mcp: "none",
+  cli: "none"
+};
+var mcpOnlyInternal = {
+  sdk: "none",
+  rest: "none",
+  mcp: "internal",
+  cli: "none"
+};
+function entries(names, surfaceClass, surfaceIntent, surfaces, rationale) {
+  return Object.fromEntries(
+    names.map((name) => [
+      name,
+      {
+        name,
+        surfaceClass,
+        surfaceIntent,
+        surfaces,
+        rationale
+      }
+    ])
+  );
+}
+var MCP_CORE_OPERATION_NAMES = [
+  "compile_context",
+  "identity_whoami",
+  "check_permission",
+  "filter_by_permission",
+  "create_belief",
+  "get_belief",
+  "list_beliefs",
+  "refine_belief",
+  "modulate_confidence",
+  "fork_belief",
+  "archive_belief",
+  "search_beliefs",
+  "bisect_confidence",
+  "create_evidence",
+  "get_evidence",
+  "list_evidence",
+  "search_evidence",
+  "link_evidence_to_belief",
+  "link_evidence_to_question",
+  "create_question",
+  "get_question",
+  "list_questions",
+  "refine_question",
+  "update_question_status",
+  "archive_question",
+  "create_answer",
+  "get_answer",
+  "find_missing_questions",
+  "get_high_priority_questions",
+  "get_falsification_questions",
+  "create_topic",
+  "get_topic",
+  "list_topics",
+  "update_topic",
+  "get_topic_tree"
+];
+var MCP_ANALYSIS_PLATFORM_OPERATION_NAMES = [
+  "create_edge",
+  "query_lineage",
+  "traverse_graph",
+  "get_graph_neighborhood",
+  "get_graph_structure_analysis",
+  "find_contradictions",
+  "flag_contradiction",
+  "detect_confirmation_bias",
+  "get_topic_coverage",
+  "get_graph_gaps"
+];
+var MCP_ANALYSIS_TENANT_OPERATION_NAMES = [
+  "analyze_topic_density",
+  "discover_entity_connections",
+  "trace_entity_impact"
+];
+var MCP_WORKFLOW_PLATFORM_OPERATION_NAMES = [
+  "list_lenses",
+  "apply_lens_to_topic",
+  "remove_lens_from_topic",
+  "get_ontology",
+  "list_ontologies",
+  "apply_ontology",
+  "match_entity_type",
+  "resolve_effective_ontology",
+  "add_worktree",
+  "activate_worktree",
+  "list_worktrees",
+  "list_all_worktrees",
+  "update_worktree_targets",
+  "update_worktree_metadata",
+  "create_task",
+  "list_tasks",
+  "update_task",
+  "complete_task"
+];
+var MCP_WORKFLOW_TENANT_OPERATION_NAMES = [
+  "resolve_effective_ontology",
+  "get_observation_context",
+  "ingest_observation",
+  "merge"
+];
+var MCP_GOVERNANCE_PLATFORM_OPERATION_NAMES = [
+  "create_lens",
+  "create_ontology",
+  "update_ontology",
+  "archive_ontology",
+  "create_ontology_version"
+];
+var MCP_GOVERNANCE_TENANT_OPERATION_NAMES = [
+  "create_epistemic_contract",
+  "evaluate_contract",
+  "get_contract_status",
+  "publish_ontology_version",
+  "deprecate_ontology_version",
+  "manage_write_policy"
+];
+var MCP_AUTOMATION_OPERATION_NAMES = [
+  "apply_auto_branching",
+  "trigger_belief_review"
+];
+var DUPLICATE_OPERATION_NAMES = [
+  "link_evidence"
+];
+var PLATFORM_INTERNAL_OPERATION_NAMES = [
+  "register_session",
+  "heartbeat_session",
+  "end_session",
+  "list_active_sessions",
+  "send_agent_message",
+  "broadcast_message",
+  "get_agent_inbox",
+  "claim_files",
+  "generate_session_handoff",
+  "record_scope_learning",
+  "pipeline_snapshot",
+  "seed_belief_lattice",
+  "get_lattice_coverage",
+  "get_code_context",
+  "get_change_history",
+  "get_failure_log",
+  "record_attempt",
+  "push",
+  "open_pull_request",
+  "record_judgment",
+  "get_audit_trail"
+];
+var LEGACY_COMPAT_OPERATION_NAMES = [
+  "discover",
+  "add_evidence",
+  "answer_question",
+  "get_confidence_history"
+];
+var SDK_ONLY_OPERATION_NAMES = [
+  "start_worktree",
+  "update_worktree_phase",
+  "advance_worktree_phase",
+  "add_note_to_worktree",
+  "link_document_to_worktree",
+  "link_evidence_to_worktree",
+  "link_question_to_worktree",
+  "link_belief_to_worktree",
+  "create_synthesized_belief",
+  "complete_hypothesis_formation",
+  "complete_evidence_review",
+  "refine_worktree_belief",
+  "trace_provenance",
+  "get_belief_relationships",
+  "get_belief_support_chain",
+  "explore_connections",
+  "get_deep_lineage",
+  "graph_aware_search",
+  "get_collection_conviction",
+  "get_conviction_trend",
+  "analyze_belief_criticality",
+  "analyze_belief_cluster_candidates",
+  "create_belief_conditional",
+  "get_necessary_evidence",
+  "analyze_reasoning_depth",
+  "get_evidence_by_methodology",
+  "create_evidence_task",
+  "get_task_counts",
+  "add_research_action",
+  "get_predictions",
+  "get_surprise_detection",
+  "get_challenged_beliefs",
+  "get_causal_chains",
+  "get_non_consensus_beliefs",
+  "get_beliefs_by_epistemic_status",
+  "detect_anchoring_bias",
+  "detect_source_concentration",
+  "find_soft_contradictions",
+  "find_semantic_bridges",
+  "find_semantic_orphans"
+];
+var MCP_ONLY_INTERNAL_OPERATION_NAMES = [
+  "begin_build_session",
+  "evaluate_engineering_contract",
+  "evaluate_research_contract"
+];
+var LUCERN_OPERATION_MANIFEST = {
+  ...entries(
+    MCP_CORE_OPERATION_NAMES,
+    "platform_public",
+    "mcp_core",
+    publicEverywhere,
+    "Default conversational Lucern MCP primitive for reading, writing, and shaping the reasoning graph."
+  ),
+  ...entries(
+    MCP_ANALYSIS_PLATFORM_OPERATION_NAMES,
+    "platform_public",
+    "mcp_analysis",
+    publicEverywhere,
+    "High-signal graph analysis operation that belongs in chat/MCP because users naturally ask for gaps, contradictions, lineage, and coverage."
+  ),
+  ...entries(
+    MCP_ANALYSIS_TENANT_OPERATION_NAMES,
+    "tenant_public",
+    "mcp_analysis",
+    publicEverywhere,
+    "Tenant-scoped analysis operation that remains MCP-visible because agents can answer graph-quality and impact questions from chat."
+  ),
+  ...entries(
+    MCP_WORKFLOW_PLATFORM_OPERATION_NAMES,
+    "platform_public",
+    "mcp_workflow",
+    publicEverywhere,
+    "Workflow operation expected by coding agents and human MCP users managing Lucern worktrees, tasks, lenses, and observations."
+  ),
+  ...entries(
+    MCP_WORKFLOW_TENANT_OPERATION_NAMES,
+    "tenant_public",
+    "mcp_workflow",
+    publicEverywhere,
+    "Tenant-scoped workflow operation expected by coding agents and human MCP users managing observations and worktree lifecycle."
+  ),
+  ...entries(
+    MCP_AUTOMATION_OPERATION_NAMES,
+    "tenant_public",
+    "mcp_analysis",
+    publicEverywhere,
+    "Tenant-scoped automation that remains MCP-visible because agents can explicitly request review or branching assistance."
+  ),
+  ...entries(
+    MCP_GOVERNANCE_PLATFORM_OPERATION_NAMES,
+    "platform_public",
+    "mcp_governance",
+    publicWithInternalMcp,
+    "Governance/admin operation. SDK, REST, and CLI remain public, but MCP is internal by default to keep chat surfaces focused."
+  ),
+  ...entries(
+    MCP_GOVERNANCE_TENANT_OPERATION_NAMES,
+    "tenant_public",
+    "mcp_governance",
+    publicWithInternalMcp,
+    "Governance/admin operation. SDK, REST, and CLI remain public, but MCP is internal by default to keep chat surfaces focused."
+  ),
+  ...entries(
+    DUPLICATE_OPERATION_NAMES,
+    "platform_public",
+    "compatibility",
+    publicWithoutMcp,
+    "Duplicate compatibility operation kept for SDK/REST callers, removed from MCP/CLI discovery in favor of the canonical specific tool."
+  ),
+  ...entries(
+    PLATFORM_INTERNAL_OPERATION_NAMES,
+    "platform_internal",
+    "system",
+    internalSystem,
+    "Lucern system/background operation. Available to platform code paths, hidden from public MCP discovery."
+  ),
+  ...entries(
+    LEGACY_COMPAT_OPERATION_NAMES,
+    "legacy_compat",
+    "compatibility",
+    publicWithoutMcp,
+    "Temporary compatibility operation. Must name a canonical replacement before removal."
+  ),
+  ...entries(
+    SDK_ONLY_OPERATION_NAMES,
+    "tenant_public",
+    "sdk_granular",
+    sdkOnlyPublic,
+    "Granular Lucern SDK operation. Not an MCP, REST, or CLI tool until backed by the generated function pipe."
+  ),
+  ...entries(
+    MCP_ONLY_INTERNAL_OPERATION_NAMES,
+    "platform_internal",
+    "system",
+    mcpOnlyInternal,
+    "Lucern MCP-only platform operation for local agent/bootstrap or verification workflows. Hidden from public discovery."
+  )
+};
+
+// src/function-registry/helpers.ts
+var jsonObjectSchema = z.record(z.unknown());
+function mcpContractShape(contract) {
+  const required = new Set(contract.required);
+  return Object.fromEntries(
+    Object.entries(contract.parameters).map(([name, parameter]) => {
+      const schema = schemaForMcpParameter(parameter);
+      return [
+        name,
+        required.has(name) || parameter.required ? schema : schema.optional()
+      ];
+    })
+  );
+}
+function schemaForMcpParameter(parameter) {
+  if (parameter.enum && parameter.enum.length > 0) {
+    const [first, ...rest] = parameter.enum;
+    return z.enum([first, ...rest]);
+  }
+  switch (parameter.type) {
+    case "array":
+      return z.array(z.unknown());
+    case "boolean":
+      return z.boolean();
+    case "number":
+      return z.number();
+    case "object":
+      return z.record(z.unknown());
+    case "string":
+      return z.string();
+  }
+}
+function argsSchemaFromMcpContract(contract) {
+  return z.object(mcpContractShape(contract));
+}
+function inputSchemaFromMcpContract(contract) {
+  return argsSchemaFromMcpContract(contract).passthrough();
+}
+function getObjectShape(schema) {
+  const shape = typeof schema._def.shape === "function" ? schema._def.shape() : schema._def.shape;
+  return shape;
+}
+function unwrapMcpParameterSchema(schema) {
+  let current = schema;
+  let required = true;
+  let description = schema.description;
+  while (true) {
+    description ??= current.description;
+    switch (current._def.typeName) {
+      case z.ZodFirstPartyTypeKind.ZodOptional:
+      case z.ZodFirstPartyTypeKind.ZodDefault:
+        required = false;
+        current = current._def.innerType;
+        continue;
+      case z.ZodFirstPartyTypeKind.ZodNullable:
+        current = current._def.innerType;
+        continue;
+      case z.ZodFirstPartyTypeKind.ZodBranded:
+        current = current._def.type;
+        continue;
+      default:
+        return { schema: current, required, description: description ?? current.description };
+    }
+  }
+}
+function mcpParameterFromZod(fieldName, schema, contractName) {
+  const { schema: unwrapped, required, description: schemaDescription } = unwrapMcpParameterSchema(schema);
+  const description = schemaDescription ?? unwrapped.description ?? fieldName;
+  switch (unwrapped._def.typeName) {
+    case z.ZodFirstPartyTypeKind.ZodString:
+      return { parameter: { type: "string", description }, required };
+    case z.ZodFirstPartyTypeKind.ZodNumber:
+      return { parameter: { type: "number", description }, required };
+    case z.ZodFirstPartyTypeKind.ZodBoolean:
+      return { parameter: { type: "boolean", description }, required };
+    case z.ZodFirstPartyTypeKind.ZodArray:
+      return { parameter: { type: "array", description }, required };
+    case z.ZodFirstPartyTypeKind.ZodObject:
+    case z.ZodFirstPartyTypeKind.ZodRecord:
+      return { parameter: { type: "object", description }, required };
+    case z.ZodFirstPartyTypeKind.ZodEnum:
+      return {
+        parameter: {
+          type: "string",
+          description,
+          enum: [...unwrapped._def.values]
+        },
+        required
+      };
+    case z.ZodFirstPartyTypeKind.ZodLiteral:
+      if (typeof unwrapped._def.value === "string") {
+        return {
+          parameter: {
+            type: "string",
+            description,
+            enum: [unwrapped._def.value]
+          },
+          required
+        };
+      }
+      break;
+  }
+  throw new Error(
+    `Function surface contract ${contractName}.${fieldName} cannot be lowered to an MCP parameter from ${unwrapped._def.typeName}.`
+  );
+}
+function mcpContractFromArgsSchema(base, args, contractName) {
+  const entries2 = Object.entries(getObjectShape(args)).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  const converted = entries2.map(([fieldName, schema]) => [
+    fieldName,
+    mcpParameterFromZod(fieldName, schema, contractName)
+  ]);
+  return {
+    ...base,
+    parameters: Object.fromEntries(
+      converted.map(([fieldName, field]) => [fieldName, field.parameter])
+    ),
+    required: converted.filter(([, field]) => field.required).map(([fieldName]) => fieldName)
+  };
+}
+function defineFunctionContract(contract) {
+  return contract;
+}
+function classifyContract(contract, surfaceClass) {
+  return {
+    ...contract,
+    surfaceClass: contract.surfaceClass ?? surfaceClass
+  };
+}
+function authUserId(context) {
+  return context.userId ?? context.principalId ?? "lucern-agent";
+}
+function withUserId(input, context) {
+  return {
+    ...input,
+    userId: typeof input.userId === "string" ? input.userId : authUserId(context)
+  };
+}
+function withCreatedBy(input, context) {
+  return {
+    ...input,
+    createdBy: typeof input.createdBy === "string" ? input.createdBy : authUserId(context)
+  };
+}
+function surfaceMcpContract(name) {
+  const contract = MCP_TOOL_CONTRACTS[name];
+  if (!contract) {
+    throw new Error(
+      `Function surface contract ${name} is missing from MCP_TOOL_CONTRACTS.`
+    );
+  }
+  return {
+    ...contract,
+    exposed: true,
+    toolName: contract.name
+  };
+}
+function deriveFunctionEffects(args) {
+  if (args.kind === "query") {
+    return ["read"];
+  }
+  if (args.surfaceIntent === "system" || args.surfaceIntent === "mcp_governance" || args.domain === "identity" || args.domain === "contracts" || args.domain === "coordination" || args.domain === "pipeline") {
+    return ["admin"];
+  }
+  return ["write"];
+}
+function surfaceContract(args) {
+  const manifest = LUCERN_OPERATION_MANIFEST;
+  const manifestEntry = manifest[args.name];
+  if (!manifestEntry) {
+    throw new Error(
+      `Function surface contract ${args.name} is not in LUCERN_OPERATION_MANIFEST.`
+    );
+  }
+  if (manifestEntry.surfaceClass !== args.surfaceClass) {
+    throw new Error(
+      `Function surface contract ${args.name} is classified as ${args.surfaceClass}, but manifest requires ${manifestEntry.surfaceClass}.`
+    );
+  }
+  if (manifestEntry.surfaces.sdk === "none" && manifestEntry.surfaces.rest === "none") {
+    throw new Error(
+      `Function surface contract ${args.name} has no SDK or REST exposure in the manifest.`
+    );
+  }
+  const baseMcp = surfaceMcpContract(args.name);
+  const canonicalArgs = args.args ?? argsSchemaFromMcpContract(baseMcp);
+  const mcp = args.args ? mcpContractFromArgsSchema(baseMcp, canonicalArgs, args.name) : baseMcp;
+  const canonicalReturns = args.returns ?? jsonObjectSchema;
+  const input = args.input ?? inputSchemaFromMcpContract(mcp);
+  const output = args.output ?? canonicalReturns;
+  return defineFunctionContract({
+    name: args.name,
+    kind: args.kind,
+    idempotent: args.idempotent ?? (args.kind === "query" ? false : true),
+    effects: args.effects ?? deriveFunctionEffects({
+      kind: args.kind,
+      domain: args.domain,
+      surfaceIntent: manifestEntry.surfaceIntent
+    }),
+    invariants: args.invariants,
+    surfaceIntent: manifestEntry.surfaceIntent,
+    domain: args.domain,
+    surfaceClass: manifestEntry.surfaceClass,
+    surfaces: manifestEntry.surfaces,
+    replacedBy: args.replacedBy,
+    rest: {
+      method: args.method ?? "POST",
+      path: args.path
+    },
+    sdk: {
+      namespace: args.sdkNamespace,
+      method: args.sdkMethod
+    },
+    mcp,
+    auth: {
+      scopes: args.scopes ?? [
+        args.kind === "query" ? `${args.domain}.read` : `${args.domain}.write`
+      ],
+      allowedPrincipalTypes: ["user", "service", "agent"]
+    },
+    convex: args.convex,
+    args: canonicalArgs,
+    returns: canonicalReturns,
+    input,
+    output,
+    openapi: {
+      summary: args.summary,
+      tags: args.tags ?? [args.domain]
+    }
+  });
+}
+function assertSurfaceCoverage(contracts) {
+  const names = /* @__PURE__ */ new Set();
+  for (const contract of contracts) {
+    if (names.has(contract.name)) {
+      throw new Error(`Duplicate function contract name: ${contract.name}`);
+    }
+    names.add(contract.name);
+  }
+  for (const contract of contracts) {
+    if (contract.replacedBy && !names.has(contract.replacedBy)) {
+      throw new Error(
+        `Function contract ${contract.name} replacedBy target ${contract.replacedBy} is not registered.`
+      );
+    }
+  }
+}
+
+export { argsSchemaFromMcpContract, assertSurfaceCoverage, authUserId, classifyContract, defineFunctionContract, inputSchemaFromMcpContract, jsonObjectSchema, surfaceContract, surfaceMcpContract, withCreatedBy, withUserId };
+//# sourceMappingURL=helpers.js.map
+//# sourceMappingURL=helpers.js.map