@lucern/contracts 1.0.0 → 1.0.1

package/dist/tool-contracts.values.js

@@ -0,0 +1,4398 @@
+// src/types/reasoning-method.ts
+var REASONING_METHODS = [
+  "deductive",
+  "inductive",
+  "abductive",
+  "analogical",
+  "causal",
+  "correlational",
+  "testimonial",
+  "statistical",
+  "implicit",
+  "pattern_match"
+];
+
+// src/tool-contracts.graph.ts
+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 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 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. Accepts any public epistemic edge type between public graph node refs so agents can author the full spine.",
+  parameters: {
+    from: {
+      type: "object",
+      description: "Source graph ref, e.g. { kind: 'epistemic_node', nodeId: '...', nodeType: 'topic' }"
+    },
+    to: {
+      type: "object",
+      description: "Target graph ref, e.g. { kind: 'epistemic_node', nodeId: '...', nodeType: 'belief' }"
+    },
+    edgeType: {
+      type: "string",
+      description: "Relationship type from the public epistemic edge enum."
+    },
+    globalId: {
+      type: "string",
+      description: "Optional idempotent edge global ID."
+    },
+    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: [...REASONING_METHODS]
+    },
+    metadata: {
+      type: "object",
+      description: "Optional edge metadata."
+    }
+  },
+  required: ["from", "to", "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 UPDATE_EDGE = {
+  name: "update_edge",
+  description: "Amend metadata on an existing graph edge. Like `git commit --amend` \u2014 changes the edge annotation without recreating the relationship.",
+  parameters: {
+    edgeId: { type: "string", description: "Edge ID or global ID to update" },
+    weight: { type: "number", description: "Updated edge weight" },
+    confidence: { type: "number", description: "Updated confidence" },
+    context: { type: "string", description: "Updated human-readable context" },
+    derivationType: { type: "string", description: "Updated derivation type" },
+    metadata: { type: "object", description: "Updated metadata" }
+  },
+  required: ["edgeId"],
+  response: {
+    description: "Edge update result",
+    fields: { success: "boolean" }
+  },
+  ownerModule: "graph-primitives",
+  ontologyPrimitive: "edge",
+  tier: "workhorse"
+};
+var REMOVE_EDGE = {
+  name: "remove_edge",
+  description: "Remove one graph edge by ID. Like `git rm` \u2014 deletes a single explicit relationship from the spine.",
+  parameters: {
+    edgeId: { type: "string", description: "Edge ID or global ID to remove" }
+  },
+  required: ["edgeId"],
+  response: {
+    description: "Edge removal result",
+    fields: { success: "boolean" }
+  },
+  ownerModule: "graph-primitives",
+  ontologyPrimitive: "edge",
+  tier: "workhorse"
+};
+var REMOVE_EDGES_BETWEEN = {
+  name: "remove_edges_between",
+  description: "Remove graph edges between two nodes. Like `git rm <pathspec>` \u2014 deletes relationships matching a source, target, and optional type.",
+  parameters: {
+    fromNodeId: { type: "string", description: "Source node ID or global ID" },
+    toNodeId: { type: "string", description: "Target node ID or global ID" },
+    edgeType: { type: "string", description: "Optional edge type filter" }
+  },
+  required: ["fromNodeId", "toNodeId"],
+  response: {
+    description: "Matched edge removal result",
+    fields: { deleted: "number" }
+  },
+  ownerModule: "graph-primitives",
+  ontologyPrimitive: "edge",
+  tier: "workhorse"
+};
+var BATCH_CREATE_EDGES = {
+  name: "batch_create_edges",
+  description: "Commit multiple typed graph edges. Like `git commit` with many staged paths \u2014 writes a batch of explicit relationships atomically per edge.",
+  parameters: {
+    edges: {
+      type: "array",
+      description: "Edges to create, each with from, to, edgeType, and optional weight/confidence/context."
+    },
+    skipLayerValidation: {
+      type: "boolean",
+      description: "Skip kernel layer validation for trusted materialization flows."
+    }
+  },
+  required: ["edges"],
+  response: {
+    description: "Batch edge creation result",
+    fields: {
+      created: "number",
+      results: "array",
+      errors: "array"
+    }
+  },
+  ownerModule: "graph-primitives",
+  ontologyPrimitive: "edge",
+  tier: "workhorse"
+};
+
+// src/tool-contracts.intelligence-evidence.ts
+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 LIST_GRAPH_INTELLIGENCE_QUERIES = {
+  name: "list_graph_intelligence_queries",
+  description: "List the Graph Intelligence query catalog that powers structural graph analysis experiences. Returns categories, query IDs, prompt templates, modes, and the public tool plan each query can use.",
+  parameters: {
+    categoryId: {
+      type: "string",
+      description: "Optional category filter, such as problems or strategic"
+    },
+    mode: {
+      type: "string",
+      description: "Optional mode filter: core, bias, stress, operational, alpha, semantic, or evidence"
+    }
+  },
+  required: [],
+  response: {
+    description: "Graph Intelligence query catalog and mode-to-tool mapping",
+    fields: {
+      categories: "array \u2014 query categories",
+      queries: "array \u2014 query definitions with prompt templates and tools",
+      quickQueries: "array \u2014 recommended one-click query presets",
+      publicToolNamesByMode: "object \u2014 public tool names available to each Graph Intelligence mode"
+    }
+  },
+  ownerModule: "graph-intelligence",
+  ontologyPrimitive: "graph",
+  tier: "showcase"
+};
+var RUN_GRAPH_INTELLIGENCE_QUERY = {
+  name: "run_graph_intelligence_query",
+  description: "Run a named Graph Intelligence query against a tenant topic graph. Returns the selected query, prompt, deterministic graph-analysis bundle, graph context, and public tool plan for model synthesis.",
+  parameters: {
+    topicId: { type: "string", description: "Topic to analyze" },
+    queryId: {
+      type: "string",
+      description: "Graph Intelligence query ID, such as confirmation-bias, pre-mortem, or thesis-summary"
+    },
+    prompt: {
+      type: "string",
+      description: "Optional custom prompt for custom analysis runs"
+    },
+    input: {
+      type: "string",
+      description: "Optional entity, theme, belief, company, or search text for input-driven queries"
+    },
+    mode: {
+      type: "string",
+      description: "Optional mode override: core, bias, stress, operational, alpha, semantic, or evidence"
+    },
+    limit: {
+      type: "number",
+      description: "Maximum graph context rows to return"
+    }
+  },
+  required: ["topicId"],
+  response: {
+    description: "Graph Intelligence query result bundle ready for model or prompt-library synthesis",
+    fields: {
+      query: "object \u2014 selected query definition",
+      prompt: "string \u2014 resolved prompt template",
+      toolPlan: "array \u2014 public tools and args the model can call next",
+      analysis: "object \u2014 structure, coverage, gap, and confirmation-bias analysis",
+      context: "object \u2014 sampled beliefs, questions, evidence, edges, and contradictions"
+    }
+  },
+  ownerModule: "graph-intelligence",
+  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"
+    },
+    rationale: {
+      type: "string",
+      description: "Why this evidence should enter the reasoning graph"
+    },
+    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", "rationale"],
+  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: ["topicId"],
+  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"
+};
+
+// src/tool-contracts.lifecycle.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 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: "Prior probability used to seed the vacuous opinion `(0, 0, 1, a)` at creation time. Defaults to 0.5 when omitted."
+    },
+    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"],
+  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. Every modulation must cite a truth-bearing artifact: triggeringEvidenceId, triggeringQuestionId, triggeringAnswerId, triggeringContradictionId, or triggeringWorktreeId. Triggers: evidence_added, evidence_removed, contradiction_detected, contradiction_resolved, agent_assessment, worktree_outcome, worktree_completed, fusion, discount, deduction.",
+  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."
+    },
+    worktreeId: {
+      type: "string",
+      description: "Completed worktree that tested this belief when confidence policy requires merge-backed scoring."
+    },
+    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"
+      ]
+    },
+    triggeringEvidenceId: {
+      type: "string",
+      description: "Evidence node that caused an evidence-triggered modulation"
+    },
+    triggeringQuestionId: {
+      type: "string",
+      description: "Answered question whose resolution supports this modulation"
+    },
+    triggeringAnswerId: {
+      type: "string",
+      description: "Answer node whose content supports this modulation"
+    },
+    triggeringContradictionId: {
+      type: "string",
+      description: "Contradiction record that caused a contradiction-triggered modulation"
+    },
+    triggeringWorktreeId: {
+      type: "string",
+      description: "Completed worktree whose outcome caused a worktree-triggered modulation"
+    },
+    rationale: {
+      type: "string",
+      description: "Human-readable explanation of why confidence changed"
+    }
+  },
+  required: [
+    "nodeId",
+    "belief",
+    "disbelief",
+    "uncertainty",
+    "baseRate",
+    "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", "reasoning"],
+  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"
+};
+
+// src/lens-workflow.contract.ts
+var LENS_PERSPECTIVE_TYPES = [
+  "investigation",
+  "monitoring",
+  "analysis",
+  "comparison",
+  "taxonomy"
+];
+
+// src/tool-contracts.nodes-lenses.ts
+var CREATE_EPISTEMIC_NODE = {
+  name: "create_epistemic_node",
+  description: "Commit a generic epistemic graph node. Like `git commit` \u2014 creates a canonical node in the public spine for topics, beliefs, evidence, questions, answers, sources, and entities.",
+  parameters: {
+    globalId: { type: "string", description: "Optional idempotent node global ID" },
+    nodeType: { type: "string", description: "Public epistemic node type" },
+    canonicalText: { type: "string", description: "Canonical node text" },
+    text: { type: "string", description: "Alias for canonicalText" },
+    contentHash: { type: "string", description: "Optional idempotency content hash" },
+    sourceType: { type: "string", description: "Source type for provenance" },
+    topicId: { type: "string", description: "Optional topic scope" },
+    content: { type: "string", description: "Extended content" },
+    title: { type: "string", description: "Display title" },
+    metadata: { type: "object", description: "Optional node metadata" }
+  },
+  required: ["nodeType"],
+  response: {
+    description: "Created node result",
+    fields: {
+      nodeId: "string",
+      nodeGlobalId: "string",
+      isDuplicate: "boolean"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "showcase"
+};
+var GET_EPISTEMIC_NODE = {
+  name: "get_epistemic_node",
+  description: "Read one epistemic graph node. Like `git show` \u2014 resolves a canonical spine node by ID or global ID.",
+  parameters: {
+    nodeId: { type: "string", description: "Node ID or global ID" }
+  },
+  required: ["nodeId"],
+  response: {
+    description: "The resolved node",
+    fields: { node: "object" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var LIST_EPISTEMIC_NODES = {
+  name: "list_epistemic_nodes",
+  description: "List epistemic graph nodes. Like `git ls-tree` \u2014 lists canonical spine nodes by topic, type, status, or search query.",
+  parameters: {
+    topicId: { type: "string", description: "Optional topic scope" },
+    nodeType: { type: "string", description: "Optional node type filter" },
+    status: { type: "string", description: "Optional lifecycle status" },
+    searchQuery: { type: "string", description: "Optional text search query" },
+    limit: { type: "number", description: "Maximum nodes to return" }
+  },
+  required: [],
+  response: {
+    description: "Matching nodes",
+    fields: { nodes: "array" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var UPDATE_EPISTEMIC_NODE = {
+  name: "update_epistemic_node",
+  description: "Amend an epistemic graph node. Like `git commit --amend` \u2014 updates mutable node metadata, text, status, or verification fields.",
+  parameters: {
+    nodeId: { type: "string", description: "Node ID or global ID" },
+    canonicalText: { type: "string", description: "Updated canonical text" },
+    text: { type: "string", description: "Alias for canonicalText" },
+    contentHash: { type: "string", description: "Updated content hash" },
+    content: { type: "string", description: "Updated content" },
+    title: { type: "string", description: "Updated display title" },
+    metadata: { type: "object", description: "Updated metadata" },
+    confidence: { type: "number", description: "Updated confidence" },
+    verificationStatus: { type: "string", description: "Updated verification status" },
+    status: { type: "string", description: "Updated lifecycle status" }
+  },
+  required: ["nodeId"],
+  response: {
+    description: "Node update result",
+    fields: { success: "boolean" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var ARCHIVE_EPISTEMIC_NODE = {
+  name: "archive_epistemic_node",
+  description: "Archive an epistemic graph node. Like `git rm --cached` \u2014 removes a node from active traversal without hard-deleting it.",
+  parameters: {
+    nodeId: { type: "string", description: "Node ID or global ID" }
+  },
+  required: ["nodeId"],
+  response: {
+    description: "Archive result",
+    fields: { success: "boolean", effectiveStatus: "string" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var VERIFY_EPISTEMIC_NODE = {
+  name: "verify_epistemic_node",
+  description: "Record verification state on an epistemic graph node. Like `git tag` \u2014 marks the node with a reviewed verification state.",
+  parameters: {
+    nodeId: { type: "string", description: "Node ID or global ID" },
+    verificationStatus: { type: "string", description: "Verification status" },
+    confidence: { type: "number", description: "Optional confidence update" }
+  },
+  required: ["nodeId", "verificationStatus"],
+  response: {
+    description: "Verification result",
+    fields: { success: "boolean" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var SUPERSEDE_EPISTEMIC_NODE = {
+  name: "supersede_epistemic_node",
+  description: "Supersede an epistemic graph node with a new version. Like `git commit --amend` on an immutable history branch \u2014 creates the replacement and marks the old node superseded.",
+  parameters: {
+    oldNodeId: { type: "string", description: "Node ID or global ID to supersede" },
+    newGlobalId: { type: "string", description: "Optional replacement global ID" },
+    newCanonicalText: { type: "string", description: "Replacement canonical text" },
+    text: { type: "string", description: "Alias for newCanonicalText" },
+    newContentHash: { type: "string", description: "Optional replacement content hash" },
+    reason: { type: "string", description: "Reason for superseding" }
+  },
+  required: ["oldNodeId"],
+  response: {
+    description: "Supersede result",
+    fields: { oldNodeId: "string", newNodeId: "string" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var BATCH_CREATE_EPISTEMIC_NODES = {
+  name: "batch_create_epistemic_nodes",
+  description: "Commit multiple epistemic graph nodes. Like `git commit` with many staged files \u2014 writes a batch of canonical spine nodes.",
+  parameters: {
+    nodes: {
+      type: "array",
+      description: "Nodes to create with nodeType, canonicalText/text, and optional metadata."
+    }
+  },
+  required: ["nodes"],
+  response: {
+    description: "Batch node creation result",
+    fields: { created: "number", results: "array" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+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"
+};
+
+// src/tool-contracts.ontology.ts
+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' or a Permit role key such as 'workspace_admin'."
+    },
+    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: ["id"],
+  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", "ontologyId"],
+  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"
+};
+
+// src/tool-contracts.pipeline-coordination.ts
+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 campaign-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",
+      currentCampaign: "number | null",
+      nextCampaign: "number | null",
+      activeWorktrees: "array \u2014 current hinge worktree(s)",
+      nextWave: "array \u2014 worktrees in the next planned campaign",
+      readyNow: "array \u2014 planning worktrees with dependencies completed",
+      blockedBy: "array \u2014 grouped blockers",
+      criticalPath: "array \u2014 ordered incomplete worktree chain",
+      campaigns: "array \u2014 incomplete worktrees grouped by campaign",
+      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 BEGIN_BUILD_SESSION = {
+  name: "begin_build_session",
+  description: "Bootstrap a coding build session for a Lucern worktree. Like `git worktree add` plus `git status` \u2014 returns the compact context packet an agent needs before editing.",
+  parameters: {
+    worktreeId: {
+      type: "string",
+      description: "The Lucern worktree ID to bootstrap."
+    },
+    branch: {
+      type: "string",
+      description: "Optional git branch name. Auto-generated from the worktree name when omitted."
+    },
+    branchBase: {
+      type: "string",
+      description: 'Base branch for the feature branch. Default: "staging".'
+    },
+    prBase: {
+      type: "string",
+      description: 'Target branch for the PR. Default: "staging".'
+    },
+    sessionMode: {
+      type: "string",
+      description: 'Session mode: "async" for Codex/headless or "interactive" for live sessions.',
+      enum: ["async", "interactive"]
+    },
+    activateIfPlanning: {
+      type: "boolean",
+      description: "When true, automatically activate a planning worktree during bootstrap."
+    }
+  },
+  required: ["worktreeId"],
+  response: {
+    description: "A compact build-session packet with worktree metadata, graph anchors, questions, dependencies, and git defaults.",
+    fields: {
+      topicId: "string \u2014 canonical topic scope",
+      topicName: "string \u2014 human-readable topic name",
+      worktreeId: "string \u2014 worktree ID",
+      worktreeName: "string \u2014 human-readable worktree name",
+      branch: "string \u2014 git branch name",
+      branchBase: "string \u2014 base branch",
+      prBase: "string \u2014 PR target branch",
+      campaign: "number | null \u2014 top-level pipeline campaign",
+      lane: "string \u2014 campaign lane",
+      gate: "string \u2014 exit gate",
+      hypothesis: "string \u2014 worktree hypothesis",
+      focus: "string \u2014 session focus",
+      status: "string \u2014 worktree status after optional activation",
+      sessionMode: "string \u2014 async | interactive",
+      targetBeliefIds: "array \u2014 scoped belief IDs",
+      targetQuestionIds: "array \u2014 scoped question IDs",
+      taskIds: "array \u2014 assigned task IDs for this worktree",
+      incompleteTaskIds: "array \u2014 assigned task IDs that still require done/deferred/blocked proof",
+      tasks: "array \u2014 assigned task packet with id, title, status, priority, links, and summaries",
+      topBeliefs: "array \u2014 highest-confidence scoped beliefs",
+      openQuestions: "array \u2014 open scoped questions",
+      resolvedDecisions: "array \u2014 answered questions summarized for the session",
+      dependencies: "array \u2014 upstream worktrees",
+      unblocks: "array \u2014 downstream worktrees",
+      mergeOrderNotes: "string \u2014 merge ordering advisory"
+    }
+  },
+  ownerModule: "bootstrap",
+  ontologyPrimitive: "worktree",
+  tier: "showcase",
+  internal: true
+};
+
+// src/tool-contracts.policy-observation-task-topic.ts
+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 title" },
+    topicId: { type: "string", description: "Topic scope" },
+    description: {
+      type: "string",
+      description: "Long-form task description"
+    },
+    taskType: {
+      type: "string",
+      description: "Task taxonomy",
+      enum: [
+        "general",
+        "find_evidence",
+        "verify_claim",
+        "research",
+        "review",
+        "interview",
+        "analysis",
+        "track_metrics"
+      ]
+    },
+    priority: {
+      type: "string",
+      description: "Priority",
+      enum: ["urgent", "high", "medium", "low"]
+    },
+    status: {
+      type: "string",
+      description: "Initial status (defaults to todo)",
+      enum: ["todo", "in_progress", "blocked", "done"]
+    },
+    linkedWorktreeId: {
+      type: "string",
+      description: "Worktree this task belongs to"
+    },
+    linkedBeliefId: {
+      type: "string",
+      description: "Belief this task supports"
+    },
+    linkedQuestionId: {
+      type: "string",
+      description: "Question this task addresses"
+    },
+    assigneeId: {
+      type: "string",
+      description: "Principal assigned to the task"
+    },
+    dueDate: {
+      type: "number",
+      description: "Due date as epoch milliseconds"
+    },
+    tags: {
+      type: "array",
+      description: "Free-form string tags"
+    },
+    metadata: {
+      type: "object",
+      description: "Structured task metadata for handoff context and routing hints"
+    }
+  },
+  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"]
+    },
+    metadata: {
+      type: "object",
+      description: "Structured task metadata to replace or refine"
+    }
+  },
+  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"
+    },
+    worktreeId: {
+      type: "string",
+      description: "Alias for linkedWorktreeId"
+    },
+    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: {
+    globalId: {
+      type: "string",
+      description: "Optional idempotent topic global ID"
+    },
+    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"
+    },
+    parentTopicGlobalId: {
+      type: "string",
+      description: "Optional parent topic global ID for nesting"
+    },
+    tenantId: { type: "string", description: "Optional tenant scope" },
+    workspaceId: { type: "string", description: "Optional workspace scope" },
+    visibility: {
+      type: "string",
+      description: "Topic visibility",
+      enum: ["private", "team", "firm", "external", "public"]
+    },
+    metadata: { type: "object", description: "Optional topic metadata" },
+    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",
+      topicGlobalId: "string \u2014 topic global ID",
+      epistemicNodeId: "string \u2014 materialized topic node ID",
+      epistemicNodeGlobalId: "string \u2014 materialized topic node global 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: ["topicId"],
+  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 MATERIALIZE_TOPIC_GRAPH = {
+  name: "materialize_topic_graph",
+  description: "Backfill the topic graph spine. Like `git fsck --connectivity-only` with repair enabled \u2014 creates missing topic nodes and parent-child edges idempotently.",
+  parameters: {
+    rootTopicId: {
+      type: "string",
+      description: "Optional root topic for a bounded materialization pass"
+    },
+    dryRun: {
+      type: "boolean",
+      description: "When true, report missing rows without writing them"
+    }
+  },
+  required: [],
+  response: {
+    description: "Topic graph materialization counts",
+    fields: {
+      topicsSeen: "number",
+      nodesCreated: "number",
+      nodesExisting: "number",
+      edgesCreated: "number",
+      edgesExisting: "number",
+      errors: "array"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var GET_TOPIC_GRAPH_SPINE = {
+  name: "get_topic_graph_spine",
+  description: "Verify the topic graph spine. Like `git fsck` \u2014 reads topics, materialized topic nodes, parent-child edges, and missing spine rows.",
+  parameters: {
+    rootTopicId: {
+      type: "string",
+      description: "Optional root topic for a bounded verifier pass"
+    },
+    includeTopicBeliefEdges: {
+      type: "boolean",
+      description: "Include topic -> belief edges in the verifier payload"
+    }
+  },
+  required: [],
+  response: {
+    description: "Topic graph spine verification payload",
+    fields: {
+      ok: "boolean",
+      counts: "object",
+      topics: "array",
+      topicNodes: "array",
+      parentEdges: "array",
+      missingTopicNodes: "array",
+      missingParentEdges: "array"
+    }
+  },
+  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"
+};
+
+// src/tool-contracts.questions-listing.ts
+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" },
+    topicId: { type: "string", description: "Topic scope for the answer" },
+    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", "topicId", "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"
+    },
+    limit: {
+      type: "number",
+      description: "Maximum results"
+    }
+  },
+  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 lifecycle phase, pipeline campaign/lane, status, and belief counts.",
+  parameters: {
+    topicId: { type: "string", description: "Topic scope" },
+    status: {
+      type: "string",
+      description: "Filter: active, merged, abandoned",
+      enum: ["active", "merged", "abandoned"]
+    },
+    groupBy: {
+      type: "string",
+      description: "Optional grouping mode for the response.",
+      enum: ["campaign", "lane", "flat"]
+    },
+    lane: {
+      type: "string",
+      description: "Filter by GitButler-aligned lane name."
+    },
+    campaign: {
+      type: "number",
+      description: "Filter by top-level pipeline campaign number."
+    },
+    limit: {
+      type: "number",
+      description: "Maximum results to return."
+    }
+  },
+  required: ["topicId"],
+  response: {
+    description: "Worktrees with lifecycle phase, campaign, lane, status, belief count, and creation time",
+    fields: {
+      worktrees: "array \u2014 { worktreeId, title, phase, campaign, lane, laneOrderInCampaign, orderInLane, 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 campaign, lane, lane order, dependencies, and status. Supports filtering by status, lane, and campaign. 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"
+      ]
+    },
+    lane: {
+      type: "string",
+      description: "Filter by lane name (e.g., 'ontology', 'tc-scope', 'control-plane', 'dev-portal', 'mcp-sdk-parity')"
+    },
+    campaign: {
+      type: "number",
+      description: "Filter by campaign number (e.g., 1, 2, 3). Returns only worktrees in that campaign."
+    },
+    groupBy: {
+      type: "string",
+      description: "Optional grouping mode for the response.",
+      enum: ["campaign", "lane", "flat"]
+    },
+    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, campaign, lane, laneOrderInCampaign, orderInLane, dependsOn, blocks, gate, createdAt }",
+      total: "number \u2014 total count after filtering",
+      lanes: "object \u2014 { laneName: count } summary of worktrees per lane",
+      campaigns: "object \u2014 { campaignNumber: count } summary of worktrees per campaign"
+    }
+  },
+  ownerModule: "workflow-engine",
+  ontologyPrimitive: "worktree",
+  tier: "showcase"
+};
+var GET_WORKTREE = {
+  name: "get_worktree",
+  description: "Get one worktree by ID. Like `git worktree list --porcelain <worktree>` \u2014 inspects one investigation branch without scanning the full pipeline inventory.",
+  parameters: {
+    worktreeId: { type: "string", description: "Canonical worktree ID to retrieve" },
+    id: { type: "string", description: "Legacy alias for worktreeId" }
+  },
+  required: ["worktreeId"],
+  response: {
+    description: "Single worktree record with pipeline metadata",
+    fields: {
+      worktree: "object \u2014 { worktreeId, title, topicId, status, hypothesis, campaign, lane, laneOrderInCampaign, orderInLane, dependsOn, blocks, gate }"
+    }
+  },
+  ownerModule: "workflow-engine",
+  ontologyPrimitive: "worktree",
+  tier: "workhorse"
+};
+var LIST_CAMPAIGNS = {
+  name: "list_campaigns",
+  description: "List compact pipeline campaigns with their nested lanes. Use this to see the top-level campaign > lane > worktree shape without pulling the full worktree inventory.",
+  parameters: {
+    topicId: {
+      type: "string",
+      description: "Optional topic scope."
+    },
+    status: {
+      type: "string",
+      description: "Optional worktree status filter before grouping campaigns and lanes."
+    },
+    limit: {
+      type: "number",
+      description: "Maximum worktrees to scan before grouping."
+    }
+  },
+  required: [],
+  response: {
+    description: "Pipeline campaigns with nested lane summaries.",
+    fields: {
+      campaigns: "array \u2014 { campaign, lanes: [{ lane, laneOrderInCampaign, worktreeCount, activeCount, readyCount, blockedCount, completedCount, nextWorktree }] }",
+      totalWorktrees: "number \u2014 total worktrees scanned after filtering"
+    }
+  },
+  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 campaign, lane, 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"
+    },
+    campaign: {
+      type: "number",
+      description: "Top-level pipeline campaign number."
+    },
+    lane: {
+      type: "string",
+      description: "GitButler-aligned workstream lane name inside the campaign."
+    },
+    laneOrderInCampaign: {
+      type: "number",
+      description: "Ordering for this lane within the campaign."
+    },
+    orderInLane: {
+      type: "number",
+      description: "Position of this worktree inside its lane."
+    },
+    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."
+    },
+    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 principal identifier; for humans this is the Clerk user_... ID",
+      principalType: "string \u2014 human, service, agent, group, or external_viewer",
+      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 RESOLVE_INTERACTIVE_PRINCIPAL = {
+  name: "resolve_interactive_principal",
+  description: "Read the Permit-backed Lucern principal context for an authenticated Clerk user. Like `git config --get user.email` plus the repository ACL \u2014 resolves the Clerk subject into tenant/workspace authorization context.",
+  parameters: {
+    clerkId: {
+      type: "string",
+      description: "Authenticated Clerk subject (`sub`). Clerk proves identity only; it is not the authorization record."
+    },
+    tenantId: {
+      type: "string",
+      description: "Optional tenant scope. Omit only when the Clerk alias is globally unambiguous."
+    },
+    workspaceId: {
+      type: "string",
+      description: "Optional workspace scope. Required when the principal has access to multiple workspaces and no default can be inferred."
+    },
+    providerProjectId: {
+      type: "string",
+      description: "Optional Clerk project or provider instance id for tenants with multiple identity providers."
+    }
+  },
+  required: ["clerkId"],
+  response: {
+    description: "Permit-backed Lucern principal context for tenant SDK bootstrap",
+    fields: {
+      principalId: "string \u2014 canonical Clerk user_... ID for human sessions",
+      principalType: "string \u2014 human, service, agent, group, or external_viewer",
+      clerkId: "string \u2014 authenticated Clerk subject alias",
+      tenantId: "string \u2014 resolved tenant scope",
+      workspaceId: "string | null \u2014 resolved workspace scope",
+      roles: "string[] \u2014 effective Permit roles",
+      scopes: "string[] \u2014 effective scopes derived from Permit/control-plane projection",
+      groupIds: "string[] \u2014 active Permit group memberships",
+      principalStatus: "string \u2014 active, invited, suspended, disabled, revoked, or missing",
+      tenantStatus: "string \u2014 projected tenant resource status",
+      workspaceStatus: "string \u2014 projected workspace resource status",
+      permit: "object \u2014 Permit subject, tenant, and optional workspace tuple"
+    }
+  },
+  ownerModule: "control-plane",
+  ontologyPrimitive: "identity",
+  tier: "workhorse"
+};
+var COMPILE_CONTEXT = {
+  name: "compile_context",
+  description: "Compile a focused reasoning context. If topicId is omitted, Lucern resolves the best topic from the query. 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: "Optional topic scope ID. Omit to resolve the topic from query."
+    },
+    query: {
+      type: "string",
+      description: "Focus query used to resolve the topic and rank context items. Required when topicId is omitted."
+    },
+    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: [],
+  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"
+};
+
+// src/tool-contracts.worktrees.ts
+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" },
+    name: {
+      type: "string",
+      description: "Optional storage-name alias for callers that already use backend naming"
+    },
+    projectId: {
+      type: "string",
+      description: "Legacy topicId alias or resolver hint"
+    },
+    topicId: {
+      type: "string",
+      description: "Optional topic scope hint for resolver validation"
+    },
+    topicHint: {
+      type: "string",
+      description: "Natural-language topic hint for automatic topic resolution"
+    },
+    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"
+    },
+    rationale: {
+      type: "string",
+      description: "Why this worktree exists and why it belongs in the campaign"
+    },
+    worktreeType: {
+      type: "string",
+      description: "Schema-enum worktree type used by the kernel lifecycle and retrieval layers"
+    },
+    gate: {
+      type: "string",
+      description: "Exit gate name for this worktree"
+    },
+    startDate: {
+      type: "number",
+      description: "Planned start timestamp in milliseconds since epoch"
+    },
+    endDate: {
+      type: "number",
+      description: "Planned end timestamp in milliseconds since epoch"
+    },
+    durationWeeks: {
+      type: "number",
+      description: "Planned duration in weeks"
+    },
+    confidenceImpact: {
+      type: "string",
+      description: "Expected confidence impact if the worktree succeeds",
+      enum: ["high", "medium", "low"]
+    },
+    beliefFocus: {
+      type: "string",
+      description: "Natural-language focus spanning the target belief neighborhood"
+    },
+    beliefIds: {
+      type: "array",
+      description: "Legacy alias for targetBeliefIds"
+    },
+    beliefs: {
+      type: "array",
+      description: "Legacy alias for targetBeliefIds"
+    },
+    targetBeliefIds: {
+      type: "array",
+      description: "Belief node IDs this worktree is expected to test or update"
+    },
+    targetQuestionIds: {
+      type: "array",
+      description: "Question node IDs this worktree is expected to answer"
+    },
+    keyQuestions: {
+      type: "array",
+      description: "Inline key question objects with question, optional status, answer, answerConfidence, and linkedQuestionId"
+    },
+    evidenceSignals: {
+      type: "array",
+      description: "Evidence signal objects with signal, optional collected state, progress, and notes"
+    },
+    decisionGate: {
+      type: "object",
+      description: "Decision gate object with goCriteria, noGoSignals, optional verdict, rationale, decidedAt, and decidedBy"
+    },
+    goCriteria: {
+      type: "array",
+      description: "Shorthand go criteria used to build decisionGate"
+    },
+    noGoSignals: {
+      type: "array",
+      description: "Shorthand no-go signals used to build decisionGate"
+    },
+    proofArtifacts: {
+      type: "array",
+      description: "Expected proof artifacts required to close the worktree"
+    },
+    autoShape: {
+      type: "boolean",
+      description: "Whether to invoke inquiry auto-shaping during worktree creation"
+    },
+    autoFixPolicy: {
+      type: "object",
+      description: "Policy for permitted automatic remediation inside the worktree"
+    },
+    domainPackId: {
+      type: "string",
+      description: "Optional domain pack whose shaping hooks should influence generated questions and tasks"
+    },
+    tags: {
+      type: "array",
+      description: "Additional topic-resolution tags for the worktree"
+    },
+    touchedPaths: {
+      type: "array",
+      description: "File paths used as topic-resolution signals"
+    },
+    sourceRef: {
+      type: "string",
+      description: "Source reference used as a topic-resolution signal"
+    },
+    sourceKind: {
+      type: "string",
+      description: "Source kind used as a topic-resolution signal"
+    },
+    campaign: {
+      type: "number",
+      description: "Top-level pipeline campaign number. Campaigns define the outer execution slice."
+    },
+    lane: {
+      type: "string",
+      description: "GitButler-aligned workstream lane name inside the campaign."
+    },
+    laneOrderInCampaign: {
+      type: "number",
+      description: "Ordering for this lane within its campaign."
+    },
+    orderInLane: {
+      type: "number",
+      description: "Position of this worktree inside its lane."
+    },
+    dependsOn: {
+      type: "array",
+      description: "Worktree IDs that must complete before this one can activate"
+    },
+    blocks: {
+      type: "array",
+      description: "Worktree IDs blocked by this worktree"
+    },
+    staffingHint: {
+      type: "string",
+      description: "Suggested staffing or agent allocation note"
+    },
+    lensId: {
+      type: "string",
+      description: "Lens that scopes this worktree when applicable"
+    },
+    lastReconciledAt: {
+      type: "number",
+      description: "Timestamp when worktree metadata was last reconciled"
+    }
+  },
+  required: ["title"],
+  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: "Merge outcomes as key-finding strings, or scoring outcomes for beliefs: { 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 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"
+};
+
+// src/tool-contracts.ts
+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,
+  update_edge: UPDATE_EDGE,
+  remove_edge: REMOVE_EDGE,
+  remove_edges_between: REMOVE_EDGES_BETWEEN,
+  batch_create_edges: BATCH_CREATE_EDGES,
+  // Epistemic node spine (commit/amend/show)
+  create_epistemic_node: CREATE_EPISTEMIC_NODE,
+  get_epistemic_node: GET_EPISTEMIC_NODE,
+  list_epistemic_nodes: LIST_EPISTEMIC_NODES,
+  update_epistemic_node: UPDATE_EPISTEMIC_NODE,
+  archive_epistemic_node: ARCHIVE_EPISTEMIC_NODE,
+  verify_epistemic_node: VERIFY_EPISTEMIC_NODE,
+  supersede_epistemic_node: SUPERSEDE_EPISTEMIC_NODE,
+  batch_create_epistemic_nodes: BATCH_CREATE_EPISTEMIC_NODES,
+  // Judgments (tag)
+  record_judgment: RECORD_JUDGMENT,
+  // Graph intelligence (showcase)
+  detect_confirmation_bias: DETECT_CONFIRMATION_BIAS,
+  get_graph_structure_analysis: GET_GRAPH_STRUCTURE_ANALYSIS,
+  list_graph_intelligence_queries: LIST_GRAPH_INTELLIGENCE_QUERIES,
+  run_graph_intelligence_query: RUN_GRAPH_INTELLIGENCE_QUERY,
+  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,
+  get_worktree: GET_WORKTREE,
+  list_worktrees: LIST_WORKTREES,
+  list_all_worktrees: LIST_ALL_WORKTREES,
+  list_campaigns: LIST_CAMPAIGNS,
+  activate_worktree: ACTIVATE_WORKTREE,
+  update_worktree_targets: UPDATE_WORKTREE_TARGETS,
+  update_worktree_metadata: UPDATE_WORKTREE_METADATA,
+  identity_whoami: IDENTITY_WHOAMI,
+  resolve_interactive_principal: RESOLVE_INTERACTIVE_PRINCIPAL,
+  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,
+  begin_build_session: BEGIN_BUILD_SESSION,
+  // 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,
+  materialize_topic_graph: MATERIALIZE_TOPIC_GRAPH,
+  get_topic_graph_spine: GET_TOPIC_GRAPH_SPINE,
+  // Coding intelligence (code-grounded knowledge)
+  get_code_context: GET_CODE_CONTEXT,
+  get_change_history: GET_CHANGE_HISTORY,
+  record_attempt: RECORD_ATTEMPT,
+  get_failure_log: GET_FAILURE_LOG,
+  // Graph self-intelligence (coverage, gaps)
+  get_topic_coverage: GET_TOPIC_COVERAGE,
+  get_graph_gaps: GET_GRAPH_GAPS,
+  // Ontology lifecycle (definition CRUD, version management)
+  list_ontologies: LIST_ONTOLOGIES,
+  get_ontology: GET_ONTOLOGY,
+  apply_ontology: APPLY_ONTOLOGY,
+  match_entity_type: MATCH_ENTITY_TYPE,
+  create_ontology: CREATE_ONTOLOGY,
+  update_ontology: UPDATE_ONTOLOGY,
+  archive_ontology: ARCHIVE_ONTOLOGY,
+  create_ontology_version: CREATE_ONTOLOGY_VERSION,
+  publish_ontology_version: PUBLISH_ONTOLOGY_VERSION,
+  deprecate_ontology_version: DEPRECATE_ONTOLOGY_VERSION,
+  resolve_effective_ontology: RESOLVE_EFFECTIVE_ONTOLOGY
+};
+var GIT_SEMANTIC_REQUIRED_TOOLS = Object.keys(MCP_TOOL_CONTRACTS);
+function validateGitSemantics(tool) {
+  const desc = tool.description;
+  const hasGitReference = /Like (`git |a `git |a merge conflict|opening a `git)/.test(desc);
+  if (!hasGitReference) {
+    return {
+      valid: false,
+      reason: `Tool "${tool.name}" description missing git-semantic reference`
+    };
+  }
+  return { valid: true };
+}
+
+export { ACTIVATE_WORKTREE, ADD_EVIDENCE, ADD_WORKTREE, ANALYZE_TOPIC_DENSITY, ANSWER_QUESTION, APPLY_AUTO_BRANCHING, APPLY_LENS_TO_TOPIC, APPLY_ONTOLOGY, ARCHIVE_BELIEF, ARCHIVE_EPISTEMIC_NODE, ARCHIVE_ONTOLOGY, ARCHIVE_QUESTION, BATCH_CREATE_EDGES, BATCH_CREATE_EPISTEMIC_NODES, BEGIN_BUILD_SESSION, BISECT_CONFIDENCE, BROADCAST_MESSAGE, CHECK_PERMISSION, CLAIM_FILES, COMPILE_CONTEXT, COMPLETE_TASK, CREATE_ANSWER, CREATE_BELIEF, CREATE_EDGE, CREATE_EPISTEMIC_CONTRACT, CREATE_EPISTEMIC_NODE, CREATE_EVIDENCE, CREATE_LENS, CREATE_ONTOLOGY, CREATE_ONTOLOGY_VERSION, CREATE_QUESTION, CREATE_TASK, CREATE_TOPIC, DEPRECATE_ONTOLOGY_VERSION, DETECT_CONFIRMATION_BIAS, DISCOVER, DISCOVER_ENTITY_CONNECTIONS, END_SESSION, EVALUATE_CONTRACT, FILTER_BY_PERMISSION, FIND_CONTRADICTIONS, FIND_MISSING_QUESTIONS, FLAG_CONTRADICTION, FORK_BELIEF, GENERATE_SESSION_HANDOFF, GET_AGENT_INBOX, GET_ANSWER, GET_AUDIT_TRAIL, GET_BELIEF, GET_CHANGE_HISTORY, GET_CODE_CONTEXT, GET_CONFIDENCE_HISTORY, GET_CONTRACT_STATUS, GET_EPISTEMIC_NODE, GET_EVIDENCE, GET_FAILURE_LOG, GET_FALSIFICATION_QUESTIONS, GET_GRAPH_GAPS, GET_GRAPH_NEIGHBORHOOD, GET_GRAPH_STRUCTURE_ANALYSIS, GET_HIGH_PRIORITY_QUESTIONS, GET_LATTICE_COVERAGE, GET_OBSERVATION_CONTEXT, GET_ONTOLOGY, GET_QUESTION, GET_TOPIC, GET_TOPIC_COVERAGE, GET_TOPIC_GRAPH_SPINE, GET_TOPIC_TREE, GET_WORKTREE, GIT_SEMANTIC_REQUIRED_TOOLS, HEARTBEAT_SESSION, IDENTITY_WHOAMI, INGEST_OBSERVATION, LINK_EVIDENCE, LINK_EVIDENCE_TO_BELIEF, LINK_EVIDENCE_TO_QUESTION, LIST_ACTIVE_SESSIONS, LIST_ALL_WORKTREES, LIST_BELIEFS, LIST_CAMPAIGNS, LIST_EPISTEMIC_NODES, LIST_EVIDENCE, LIST_GRAPH_INTELLIGENCE_QUERIES, LIST_LENSES, LIST_ONTOLOGIES, LIST_QUESTIONS, LIST_TASKS, LIST_TOPICS, LIST_WORKTREES, MANAGE_WRITE_POLICY, MATCH_ENTITY_TYPE, MATERIALIZE_TOPIC_GRAPH, MCP_TOOL_CONTRACTS, MERGE, MODULATE_CONFIDENCE, OPEN_PULL_REQUEST, PIPELINE_SNAPSHOT, PUBLISH_ONTOLOGY_VERSION, PUSH, QUERY_LINEAGE, RECORD_ATTEMPT, RECORD_JUDGMENT, RECORD_SCOPE_LEARNING, REFINE_BELIEF, REFINE_QUESTION, REGISTER_SESSION, REMOVE_EDGE, REMOVE_EDGES_BETWEEN, REMOVE_LENS_FROM_TOPIC, RESOLVE_EFFECTIVE_ONTOLOGY, RESOLVE_INTERACTIVE_PRINCIPAL, RUN_GRAPH_INTELLIGENCE_QUERY, SEARCH_BELIEFS, SEARCH_EVIDENCE, SEED_BELIEF_LATTICE, SEND_AGENT_MESSAGE, SUPERSEDE_EPISTEMIC_NODE, TRACE_ENTITY_IMPACT, TRAVERSE_GRAPH, TRIGGER_BELIEF_REVIEW, UPDATE_EDGE, UPDATE_EPISTEMIC_NODE, UPDATE_ONTOLOGY, UPDATE_QUESTION_STATUS, UPDATE_TASK, UPDATE_TOPIC, UPDATE_WORKTREE_METADATA, UPDATE_WORKTREE_TARGETS, VERIFY_EPISTEMIC_NODE, validateGitSemantics };
+//# sourceMappingURL=tool-contracts.values.js.map
+//# sourceMappingURL=tool-contracts.values.js.map