@lucern/mcp 0.3.0-alpha.4 → 0.3.0-alpha.5

package/dist/index.js

@@ -11,11 +11,30 @@ import { createServer } from 'http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as graphIntel_star from '@lucern/reasoning-kernel/graphIntel';
 import 'crypto';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { config } from 'dotenv';
 
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
+
 // src/execution.ts
 var SCOPE_ALIAS_GROUPS = [];
 function classifyTransportParityDrift(kind) {
@@ -382,6 +401,598 @@ function stripQuotes(value) {
   return trimmed;
 }
 
+// ../contracts/src/graph-intelligence.contract.ts
+var GRAPH_INTELLIGENCE_QUERY_CATALOG_VERSION = "graph_intelligence_query_catalog.v1";
+var GRAPH_INTELLIGENCE_QUERY_MODES = [
+  "core",
+  "bias",
+  "stress",
+  "operational",
+  "alpha",
+  "semantic",
+  "evidence"
+];
+var GRAPH_INTELLIGENCE_PUBLIC_TOOL_NAMES = [
+  "get_graph_structure_analysis",
+  "detect_confirmation_bias",
+  "get_graph_gaps",
+  "get_topic_coverage",
+  "find_contradictions",
+  "get_falsification_questions",
+  "search_beliefs",
+  "search_evidence",
+  "list_beliefs",
+  "list_questions",
+  "traverse_graph",
+  "query_lineage",
+  "get_graph_neighborhood"
+];
+var GRAPH_INTELLIGENCE_MODE_TOOL_NAMES = {
+  core: [
+    "get_graph_structure_analysis",
+    "get_topic_coverage",
+    "get_graph_gaps",
+    "list_beliefs",
+    "list_questions",
+    "search_evidence"
+  ],
+  bias: [
+    "get_graph_structure_analysis",
+    "detect_confirmation_bias",
+    "find_contradictions",
+    "search_evidence",
+    "list_beliefs"
+  ],
+  stress: [
+    "get_graph_structure_analysis",
+    "get_graph_gaps",
+    "find_contradictions",
+    "get_falsification_questions",
+    "list_beliefs",
+    "list_questions"
+  ],
+  operational: [
+    "get_topic_coverage",
+    "get_graph_gaps",
+    "list_beliefs",
+    "list_questions",
+    "search_evidence"
+  ],
+  alpha: [
+    "get_graph_structure_analysis",
+    "detect_confirmation_bias",
+    "find_contradictions",
+    "search_beliefs",
+    "search_evidence"
+  ],
+  semantic: [
+    "get_graph_structure_analysis",
+    "search_beliefs",
+    "search_evidence",
+    "traverse_graph",
+    "query_lineage",
+    "get_graph_neighborhood"
+  ],
+  evidence: [
+    "get_graph_structure_analysis",
+    "get_topic_coverage",
+    "search_evidence",
+    "get_falsification_questions",
+    "find_contradictions"
+  ]
+};
+var GRAPH_INTELLIGENCE_QUERY_CATEGORIES = [
+  {
+    id: "problems",
+    name: "Find Problems",
+    description: "Risk, contradiction, bias, and structural weakness queries."
+  },
+  {
+    id: "gaps",
+    name: "Find Gaps",
+    description: "Missing evidence, unanswered questions, and sparse areas."
+  },
+  {
+    id: "reasoning",
+    name: "Reasoning Quality",
+    description: "Assumption chains, evidence convergence, and weak links."
+  },
+  {
+    id: "strategic",
+    name: "Strategic Analysis",
+    description: "Pre-mortems, falsification, contrarian signals, and bets."
+  },
+  {
+    id: "deep",
+    name: "Deep Graph Analysis",
+    description: "Centrality, propagation, underdetermination, and topology."
+  },
+  {
+    id: "browse",
+    name: "Browse and Explore",
+    description: "Narrative summaries, search, theme exploration, and bridges."
+  },
+  {
+    id: "prep",
+    name: "Meeting Prep",
+    description: "Company, entity, and question prep from graph context."
+  }
+];
+var byMode = (mode) => GRAPH_INTELLIGENCE_MODE_TOOL_NAMES[mode];
+var GRAPH_INTELLIGENCE_QUERIES = [
+  {
+    id: "confirmation-bias",
+    categoryId: "problems",
+    mode: "bias",
+    name: "Find Confirmation Bias",
+    description: "Find beliefs supported mainly by confirming evidence.",
+    prompt: "Find beliefs where supporting evidence overwhelms challenging evidence. Prioritize high-conviction beliefs with few defeaters.",
+    highlightStrategy: "bias-risk",
+    riskLevel: "high"
+  },
+  {
+    id: "contradiction-map",
+    categoryId: "problems",
+    mode: "stress",
+    name: "Map Contradictions",
+    description: "Surface direct and indirect contradiction clusters.",
+    prompt: "Map the graph's contradiction clusters and explain which tensions matter most.",
+    highlightStrategy: "contradictions",
+    riskLevel: "high"
+  },
+  {
+    id: "weak-evidence",
+    categoryId: "problems",
+    mode: "stress",
+    name: "Weak Evidence Chains",
+    description: "Find important claims with thin or indirect evidence.",
+    prompt: "Find high-importance beliefs whose evidence support is thin, indirect, stale, or low quality.",
+    highlightStrategy: "weak-support",
+    riskLevel: "medium"
+  },
+  {
+    id: "single-source",
+    categoryId: "problems",
+    mode: "bias",
+    name: "Single-Source Risk",
+    description: "Find claims overly dependent on one source or source type.",
+    prompt: "Identify beliefs that rely on a single source, one methodology, or one repeated perspective.",
+    highlightStrategy: "source-concentration",
+    riskLevel: "medium"
+  },
+  {
+    id: "untested-assumptions",
+    categoryId: "problems",
+    mode: "stress",
+    name: "Untested Assumptions",
+    description: "Find load-bearing assumptions without falsification paths.",
+    prompt: "Find assumptions that appear load-bearing but do not have direct testing questions or falsification evidence.",
+    highlightStrategy: "untested",
+    riskLevel: "high"
+  },
+  {
+    id: "load-bearing-beliefs",
+    categoryId: "problems",
+    mode: "stress",
+    name: "Load-Bearing Beliefs",
+    description: "Find central beliefs whose failure would affect many claims.",
+    prompt: "Find the beliefs with the largest downstream impact if they are wrong.",
+    highlightStrategy: "load-bearing",
+    riskLevel: "high"
+  },
+  {
+    id: "cascade-analysis",
+    categoryId: "problems",
+    mode: "stress",
+    name: "Cascade Analysis",
+    description: "Trace what changes if a belief is weakened or invalidated.",
+    prompt: "Analyze likely downstream cascades if the most central or uncertain beliefs are weakened.",
+    highlightStrategy: "cascade",
+    riskLevel: "high"
+  },
+  {
+    id: "unanswered-questions",
+    categoryId: "gaps",
+    mode: "operational",
+    name: "Unanswered Questions",
+    description: "Find important open questions that block confidence.",
+    prompt: "Identify the most important unanswered questions and explain which beliefs they block.",
+    highlightStrategy: "open-questions"
+  },
+  {
+    id: "thin-themes",
+    categoryId: "gaps",
+    mode: "operational",
+    name: "Thin Themes",
+    description: "Find topics with shallow belief or evidence coverage.",
+    prompt: "Find themes that look underdeveloped relative to their role in the graph.",
+    highlightStrategy: "thin-themes"
+  },
+  {
+    id: "missing-evidence",
+    categoryId: "gaps",
+    mode: "stress",
+    name: "Missing Evidence",
+    description: "Find beliefs that need specific missing evidence.",
+    prompt: "Find the most valuable missing evidence needed to strengthen or falsify the graph.",
+    highlightStrategy: "missing-evidence"
+  },
+  {
+    id: "isolated-clusters",
+    categoryId: "gaps",
+    mode: "operational",
+    name: "Isolated Clusters",
+    description: "Find clusters not connected to the broader graph.",
+    prompt: "Find isolated graph clusters and recommend bridge questions or bridge evidence.",
+    highlightStrategy: "isolated-clusters"
+  },
+  {
+    id: "source-contribution",
+    categoryId: "gaps",
+    mode: "evidence",
+    name: "Source Contribution",
+    description: "Assess how source mix shapes the graph.",
+    prompt: "Assess whether the source mix is balanced enough for the graph's strongest claims.",
+    highlightStrategy: "source-mix"
+  },
+  {
+    id: "stale-beliefs",
+    categoryId: "gaps",
+    mode: "operational",
+    name: "Stale Beliefs",
+    description: "Find beliefs that need review because they are old or stale.",
+    prompt: "Find beliefs that should be revisited because they are stale, unsupported by recent evidence, or contradicted by newer context.",
+    highlightStrategy: "staleness"
+  },
+  {
+    id: "assumption-pyramid",
+    categoryId: "reasoning",
+    mode: "operational",
+    name: "Assumption Pyramid",
+    description: "Show which conclusions rest on which assumptions.",
+    prompt: "Build an assumption pyramid from the graph: foundational assumptions, intermediate claims, and top-level conclusions.",
+    highlightStrategy: "assumptions"
+  },
+  {
+    id: "converging-evidence",
+    categoryId: "reasoning",
+    mode: "evidence",
+    name: "Converging Evidence",
+    description: "Find claims supported by independent evidence streams.",
+    prompt: "Find beliefs with genuinely independent converging evidence and explain why they are robust.",
+    highlightStrategy: "convergence"
+  },
+  {
+    id: "weakest-links",
+    categoryId: "reasoning",
+    mode: "stress",
+    name: "Weakest Links",
+    description: "Find the weakest links in important reasoning chains.",
+    prompt: "Find the weakest links in important reasoning chains and explain how to test them.",
+    highlightStrategy: "weak-links",
+    riskLevel: "medium"
+  },
+  {
+    id: "challenged-beliefs",
+    categoryId: "reasoning",
+    mode: "stress",
+    name: "Challenged Beliefs",
+    description: "Find beliefs with active challenges or defeaters.",
+    prompt: "Find beliefs with active challenges, contradiction edges, or unresolved defeaters.",
+    highlightStrategy: "challenged"
+  },
+  {
+    id: "contrarian-map",
+    categoryId: "strategic",
+    mode: "alpha",
+    name: "Contrarian Map",
+    description: "Find non-consensus beliefs and where they are grounded.",
+    prompt: "Find the graph's strongest contrarian or non-consensus beliefs and explain their support.",
+    highlightStrategy: "contrarian"
+  },
+  {
+    id: "irreversibility-audit",
+    categoryId: "strategic",
+    mode: "stress",
+    name: "Irreversibility Audit",
+    description: "Find irreversible bets and assumptions behind them.",
+    prompt: "Audit irreversible decisions or beliefs and identify what must be true before acting.",
+    highlightStrategy: "irreversible",
+    riskLevel: "high"
+  },
+  {
+    id: "pre-mortem",
+    categoryId: "strategic",
+    mode: "stress",
+    name: "Pre-Mortem",
+    description: "Explain how the graph could be wrong.",
+    prompt: "Run a pre-mortem: assume the current thesis fails and identify the most plausible failure paths.",
+    highlightStrategy: "failure-paths",
+    riskLevel: "high"
+  },
+  {
+    id: "devils-advocate",
+    categoryId: "strategic",
+    mode: "stress",
+    name: "Devil's Advocate",
+    description: "Generate the strongest critique of the graph.",
+    prompt: "Produce the strongest evidence-grounded critique of the current graph and its main thesis.",
+    highlightStrategy: "critique"
+  },
+  {
+    id: "falsification-map",
+    categoryId: "strategic",
+    mode: "stress",
+    name: "Falsification Map",
+    description: "Find the cheapest tests that would disprove key beliefs.",
+    prompt: "Map the cheapest, clearest falsification tests for the graph's key claims.",
+    highlightStrategy: "falsification",
+    riskLevel: "high"
+  },
+  {
+    id: "prediction-tracker",
+    categoryId: "strategic",
+    mode: "evidence",
+    name: "Prediction Tracker",
+    description: "Find beliefs that imply measurable predictions.",
+    prompt: "Find beliefs that imply measurable predictions and suggest tracking signals.",
+    highlightStrategy: "predictions"
+  },
+  {
+    id: "belief-pagerank",
+    categoryId: "deep",
+    mode: "semantic",
+    name: "Belief PageRank",
+    description: "Identify structurally central beliefs.",
+    prompt: "Use graph centrality to identify the most structurally important beliefs.",
+    highlightStrategy: "centrality"
+  },
+  {
+    id: "underdetermination",
+    categoryId: "deep",
+    mode: "semantic",
+    name: "Underdetermination",
+    description: "Find places where evidence supports multiple explanations.",
+    prompt: "Find places where the same evidence could support multiple incompatible explanations.",
+    highlightStrategy: "underdetermination"
+  },
+  {
+    id: "confidence-propagation",
+    categoryId: "deep",
+    mode: "semantic",
+    name: "Confidence Propagation",
+    description: "Assess how uncertainty moves through the graph.",
+    prompt: "Explain how uncertainty propagates from weak or contested beliefs through downstream conclusions.",
+    highlightStrategy: "confidence-flow"
+  },
+  {
+    id: "argument-depth",
+    categoryId: "deep",
+    mode: "evidence",
+    name: "Argument Depth",
+    description: "Assess reasoning depth and chain quality.",
+    prompt: "Assess reasoning depth: where claims are shallow, deeply supported, or overextended.",
+    highlightStrategy: "depth"
+  },
+  {
+    id: "information-edge",
+    categoryId: "deep",
+    mode: "alpha",
+    name: "Information Edge",
+    description: "Find differentiated evidence or signals.",
+    prompt: "Find evidence, sources, or beliefs that could represent differentiated information edge.",
+    highlightStrategy: "information-edge"
+  },
+  {
+    id: "thesis-summary",
+    categoryId: "browse",
+    mode: "semantic",
+    name: "Thesis Summary",
+    description: "Summarize the graph's core thesis and support.",
+    prompt: "Summarize the graph's core thesis, strongest support, weakest support, and open questions.",
+    highlightStrategy: "summary"
+  },
+  {
+    id: "theme-deep-dive",
+    categoryId: "browse",
+    mode: "semantic",
+    name: "Theme Deep Dive",
+    description: "Deep dive into a named theme.",
+    prompt: "Deep dive into {input}. Explain the key beliefs, evidence, contradictions, and open questions.",
+    inputType: "theme",
+    highlightStrategy: "theme"
+  },
+  {
+    id: "belief-detail",
+    categoryId: "browse",
+    mode: "semantic",
+    name: "Belief Detail",
+    description: "Explain one belief and its graph neighborhood.",
+    prompt: "Explain {input} and its support, challenges, related beliefs, and downstream implications.",
+    inputType: "belief",
+    highlightStrategy: "belief"
+  },
+  {
+    id: "strongest-beliefs",
+    categoryId: "browse",
+    mode: "operational",
+    name: "Strongest Beliefs",
+    description: "Find the graph's strongest current beliefs.",
+    prompt: "Find the strongest current beliefs and explain why each one deserves confidence.",
+    highlightStrategy: "strongest"
+  },
+  {
+    id: "cross-theme-connection",
+    categoryId: "browse",
+    mode: "semantic",
+    name: "Cross-Theme Connections",
+    description: "Find bridges between themes.",
+    prompt: "Find meaningful connections across themes and explain which bridge beliefs matter.",
+    highlightStrategy: "bridges"
+  },
+  {
+    id: "research-velocity",
+    categoryId: "browse",
+    mode: "operational",
+    name: "Research Velocity",
+    description: "Summarize recent graph movement and momentum.",
+    prompt: "Assess research velocity: what changed recently, where progress is fastest, and what is stuck.",
+    highlightStrategy: "velocity"
+  },
+  {
+    id: "search",
+    categoryId: "browse",
+    mode: "semantic",
+    name: "Graph Search",
+    description: "Search the graph with semantic context.",
+    prompt: "Search the graph for {input}. Return the most relevant beliefs, evidence, and questions.",
+    inputType: "search",
+    highlightStrategy: "search"
+  },
+  {
+    id: "expert-coverage",
+    categoryId: "browse",
+    mode: "semantic",
+    name: "Expert Coverage",
+    description: "Assess coverage from expert/source perspectives.",
+    prompt: "Assess whether the graph has enough expert, primary, and dissenting coverage.",
+    highlightStrategy: "expert-coverage"
+  },
+  {
+    id: "value-chain-map",
+    categoryId: "browse",
+    mode: "semantic",
+    name: "Value Chain Map",
+    description: "Map entities, dependencies, and value-chain logic.",
+    prompt: "Map the value chain implied by this graph: entities, dependencies, pressure points, and missing links.",
+    highlightStrategy: "value-chain"
+  },
+  {
+    id: "meeting-brief",
+    categoryId: "prep",
+    mode: "semantic",
+    name: "Meeting Brief",
+    description: "Prepare a meeting brief from graph context.",
+    prompt: "Prepare a concise meeting brief using the graph: thesis, open questions, risks, and recommended asks.",
+    highlightStrategy: "brief"
+  },
+  {
+    id: "open-questions-entity",
+    categoryId: "prep",
+    mode: "semantic",
+    name: "Entity Open Questions",
+    description: "Find open questions about a specific entity.",
+    prompt: "Find the most important open questions about {input} and the beliefs those questions would unlock.",
+    inputType: "entity",
+    highlightStrategy: "entity-questions"
+  },
+  {
+    id: "company-context",
+    categoryId: "prep",
+    mode: "semantic",
+    name: "Company Context",
+    description: "Summarize graph context about a company.",
+    prompt: "Summarize what the graph knows about {input}: thesis relevance, evidence, risks, and open questions.",
+    inputType: "company",
+    highlightStrategy: "company"
+  },
+  {
+    id: "company-theme-fit",
+    categoryId: "prep",
+    mode: "semantic",
+    name: "Company Theme Fit",
+    description: "Assess how a company fits graph themes.",
+    prompt: "Assess how {input} fits the graph's themes and where the fit is weak or uncertain.",
+    inputType: "company",
+    highlightStrategy: "fit"
+  },
+  {
+    id: "company-comparison",
+    categoryId: "prep",
+    mode: "semantic",
+    name: "Company Comparison",
+    description: "Compare companies through graph context.",
+    prompt: "Compare {input} using graph beliefs, evidence, risks, and open questions.",
+    inputType: "company-list",
+    highlightStrategy: "comparison"
+  },
+  {
+    id: "questions-to-ask",
+    categoryId: "prep",
+    mode: "operational",
+    name: "Questions to Ask",
+    description: "Generate high-signal questions from graph gaps.",
+    prompt: "Generate the highest-signal questions to ask next, grounded in current graph gaps.",
+    highlightStrategy: "questions"
+  },
+  {
+    id: "beliefs-to-test",
+    categoryId: "prep",
+    mode: "stress",
+    name: "Beliefs to Test",
+    description: "Prioritize beliefs that should be tested next.",
+    prompt: "Prioritize the beliefs that should be tested next and explain the cheapest test for each.",
+    highlightStrategy: "tests",
+    riskLevel: "medium"
+  }
+];
+var GRAPH_INTELLIGENCE_QUERIES_WITH_TOOLS = GRAPH_INTELLIGENCE_QUERIES.map((query5) => {
+  const definition = query5;
+  return {
+    ...definition,
+    tools: definition.tools ?? byMode(definition.mode)
+  };
+});
+var GRAPH_INTELLIGENCE_QUICK_QUERIES = [
+  {
+    id: "health-check",
+    name: "Health Check",
+    queryId: "thesis-summary",
+    prompt: "Give me a fast graph health check: biggest strengths, biggest risks, and next best action."
+  },
+  {
+    id: "find-risks",
+    name: "Find Risks",
+    queryId: "weakest-links",
+    prompt: "Find the most important risks in this graph and the beliefs or evidence behind each one."
+  },
+  {
+    id: "pre-mortem",
+    name: "Pre-Mortem",
+    queryId: "pre-mortem",
+    prompt: "Assume this thesis fails. Explain the most plausible failure paths and what would reveal them early."
+  },
+  {
+    id: "whats-next",
+    name: "What's Next",
+    queryId: "questions-to-ask",
+    prompt: "What should I learn or test next to make this graph more useful?"
+  }
+];
+function isGraphIntelligenceQueryMode(value) {
+  return typeof value === "string" && GRAPH_INTELLIGENCE_QUERY_MODES.includes(value);
+}
+function getGraphIntelligenceQuery(queryId) {
+  return GRAPH_INTELLIGENCE_QUERIES_WITH_TOOLS.find(
+    (query5) => query5.id === queryId
+  );
+}
+function listGraphIntelligenceQueries(filter = {}) {
+  return GRAPH_INTELLIGENCE_QUERIES_WITH_TOOLS.filter((query5) => {
+    if (filter.categoryId && query5.categoryId !== filter.categoryId) {
+      return false;
+    }
+    if (filter.mode && query5.mode !== filter.mode) {
+      return false;
+    }
+    return true;
+  });
+}
+function fillGraphIntelligencePromptTemplate(prompt, input) {
+  const replacement = input?.trim() || "the current topic";
+  return prompt.split("{input}").join(replacement);
+}
+
 // ../contracts/src/dsl/defineTable.ts
 function defineTable(spec) {
   return spec;
@@ -398,7 +1009,10 @@ function idOf(table) {
   return schema;
 }
 var NODE_TYPE = z.enum(["decision", "belief", "question", "theme", "deal", "topic", "claim", "evidence", "synthesis", "answer", "atomic_fact", "excerpt", "source", "company", "person", "investor", "function", "value_chain"]);
-var EDGE_TYPE = z.enum(["supports", "informs", "depends_on", "extracted_from", "contains", "tests", "supersedes", "responds_to", "belongs_to", "relates_to_thesis", "works_at", "invested_in", "competes_with", "participates_in", "founded_by", "evaluates", "performs", "function_in", "impacts", "raised_from", "mentioned_in", "perspective_on", "plays_theme", "answers", "explores", "qualifies", "based_on", "based_on_belief", "based_on_question", "blocked_by_contradiction", "informed_by_theme", "same_as", "reinforces", "parent_of", "child_of", "falsified_by", "exclusive_with", "collapses_if", "cascade_from", "counterfactual_of", "cascade_to", "mutually_exclusive", "correlates_with", "amplifies", "precondition_for", "in_tension_with", "strengthened_by", "weakened_by", "alternative_to", "subsumes", "validated_by", "required_for", "blocks", "prerequisite_for", "parallel_to", "corroborates", "extends", "same_source_as", "same_theme_as", "assumes", "would_predict", "analogous_to", "independent_of", "implements", "violates", "co_changes_with", "migrating_from", "migrating_to", "scoped_by", "about_entity", "entity_referenced_in", "contradicts", "cites", "summarizes", "related_to", "partially_answers", "refines", "branches_from"]);
+var EDGE_TYPE_VALUES = ["supports", "informs", "depends_on", "derived_from", "contains", "tests", "supersedes", "responds_to", "belongs_to", "relates_to_thesis", "works_at", "invested_in", "competes_with", "participates_in", "founded_by", "evaluates", "performs", "function_in", "impacts", "raised_from", "mentioned_in", "perspective_on", "plays_theme", "answers", "explores", "qualifies", "based_on", "based_on_belief", "based_on_question", "blocked_by_contradiction", "informed_by_theme", "same_as", "reinforces", "parent_of", "child_of", "falsified_by", "exclusive_with", "collapses_if", "cascade_from", "counterfactual_of", "cascade_to", "mutually_exclusive", "correlates_with", "amplifies", "precondition_for", "in_tension_with", "strengthened_by", "weakened_by", "alternative_to", "subsumes", "validated_by", "required_for", "blocks", "prerequisite_for", "parallel_to", "corroborates", "extends", "same_source_as", "same_theme_as", "assumes", "would_predict", "analogous_to", "independent_of", "implements", "violates", "co_changes_with", "migrating_from", "migrating_to", "scoped_by", "about_entity", "entity_referenced_in", "contradicts", "cites", "summarizes", "related_to", "partially_answers", "refines", "branches_from"];
+var STORAGE_EDGE_TYPE_VALUES = [...EDGE_TYPE_VALUES, "extracted_from"];
+z.enum(EDGE_TYPE_VALUES);
+var STORAGE_EDGE_TYPE = z.enum(STORAGE_EDGE_TYPE_VALUES);
 var TOPIC_STATUS = z.enum(["active", "archived", "watching"]);
 var TOPIC_VISIBILITY = z.enum(["private", "team", "firm", "external", "public"]);
 defineTable({
@@ -1883,7 +2497,7 @@ defineTable({
     "toNodeId": z.string().optional(),
     "sourceGlobalId": z.string().optional(),
     "targetGlobalId": z.string().optional(),
-    "edgeType": EDGE_TYPE,
+    "edgeType": STORAGE_EDGE_TYPE,
     "edgeTier": z.string().optional(),
     "domainNamespace": z.string().optional(),
     "constraint": z.string().optional(),
@@ -4657,6 +5271,126 @@ var edgePolicyManifest = {
 
 // ../contracts/src/tenant-client.contract.ts
 var TENANT_CLIENT_INSTALL_TOKEN_INFISICAL_PATH = "tenants/shared";
+var TENANT_CLIENT_INSTALLABLE_PACKAGES = [
+  {
+    packageName: "@lucern/access-control",
+    role: "runtime_entrypoint",
+    directTenantImport: true
+  },
+  {
+    packageName: "@lucern/agent",
+    role: "platform_runtime",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/auth",
+    role: "sdk_dependency",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/cli",
+    role: "developer_tool",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/client-core",
+    role: "sdk_dependency",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/confidence",
+    role: "sdk_dependency",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/config",
+    role: "configuration",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/contracts",
+    role: "contract_entrypoint",
+    directTenantImport: true
+  },
+  {
+    packageName: "@lucern/control-plane",
+    role: "platform_runtime",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/developer-kit",
+    role: "developer_tool",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/events",
+    role: "sdk_dependency",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/graph-primitives",
+    role: "sdk_dependency",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/identity",
+    role: "component_runtime",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/mcp",
+    role: "runtime_entrypoint",
+    directTenantImport: true
+  },
+  {
+    packageName: "@lucern/pack-host",
+    role: "platform_runtime",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/pack-installer",
+    role: "developer_tool",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/proof-compiler",
+    role: "developer_tool",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/react",
+    role: "runtime_entrypoint",
+    directTenantImport: true
+  },
+  {
+    packageName: "@lucern/reasoning-kernel",
+    role: "component_runtime",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/sdk",
+    role: "runtime_entrypoint",
+    directTenantImport: true
+  },
+  {
+    packageName: "@lucern/server-core",
+    role: "platform_runtime",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/testing",
+    role: "test_support",
+    directTenantImport: false
+  },
+  {
+    packageName: "@lucern/types",
+    role: "contract_entrypoint",
+    directTenantImport: true
+  }
+];
+TENANT_CLIENT_INSTALLABLE_PACKAGES.map(
+  (entry) => entry.packageName
+);
 var INFISICAL_RUNTIME_DEFAULT_API_URL = "https://app.infisical.com";
 var INFISICAL_RUNTIME_DEFAULT_PROJECT_ID = "344b0526-90df-4606-ba50-22c647a36c65";
 var INFISICAL_RUNTIME_BOOTSTRAP_ENV = {
@@ -6311,6 +7045,74 @@ var GET_GRAPH_STRUCTURE_ANALYSIS = {
   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.",
@@ -8886,6 +9688,8 @@ var MCP_TOOL_CONTRACTS = {
   // 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,
@@ -8973,6 +9777,18 @@ var MCP_TOOL_CONTRACTS = {
   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 };
+}
 
 // ../contracts/src/function-registry/manifest.ts
 var publicEverywhere = {
@@ -9068,6 +9884,8 @@ var MCP_ANALYSIS_PLATFORM_OPERATION_NAMES = [
   "traverse_graph",
   "get_graph_neighborhood",
   "get_graph_structure_analysis",
+  "list_graph_intelligence_queries",
+  "run_graph_intelligence_query",
   "find_contradictions",
   "flag_contradiction",
   "detect_confirmation_bias",
@@ -11688,6 +12506,15 @@ var edgesContracts = [
     args: queryLineageArgs
   })
 ];
+var graphIntelligenceQueryModes = [
+  "core",
+  "bias",
+  "stress",
+  "operational",
+  "alpha",
+  "semantic",
+  "evidence"
+];
 var traversalLayerSchema = z.enum([
   "L4",
   "L3",
@@ -11721,6 +12548,22 @@ var graphNeighborhoodArgs = z.object({
   topicId: z.string().optional().describe("Topic scope for edge lookup."),
   limit: z.number().optional().describe("Maximum edges to return.")
 });
+var graphIntelligenceModeSchema = z.enum([
+  graphIntelligenceQueryModes[0],
+  ...graphIntelligenceQueryModes.slice(1)
+]);
+var graphIntelligenceCatalogArgs = z.object({
+  categoryId: z.string().optional().describe("Optional query category filter."),
+  mode: graphIntelligenceModeSchema.optional().describe("Optional Graph Intelligence query mode filter.")
+});
+var graphIntelligenceRunArgs = z.object({
+  topicId: z.string().describe("Topic to analyze."),
+  queryId: z.string().optional().describe("Catalog query ID to run, such as pre-mortem."),
+  prompt: z.string().optional().describe("Custom prompt when queryId is omitted or overridden."),
+  input: z.string().optional().describe("Optional entity, theme, belief, company, or search text."),
+  mode: graphIntelligenceModeSchema.optional().describe("Optional query mode override for custom prompts."),
+  limit: z.number().optional().describe("Maximum graph context rows to return.")
+});
 var flagContradictionArgs = z.object({
   beliefA: z.string().describe("First belief in tension."),
   beliefB: z.string().describe("Second belief in tension."),
@@ -11827,17 +12670,49 @@ var graphContracts = [
     }
   }),
   surfaceContract({
-    name: "find_contradictions",
+    name: "list_graph_intelligence_queries",
     kind: "query",
     domain: "graph",
     surfaceClass: "platform_public",
-    path: "/graph/contradictions",
-    sdkNamespace: "graph",
-    sdkMethod: "findContradictions",
-    summary: "Find contradiction edges.",
+    path: "/graph-intelligence/queries",
+    sdkNamespace: "graphAnalysis",
+    sdkMethod: "listGraphIntelligenceQueries",
+    summary: "List Graph Intelligence query catalog entries.",
     convex: {
-      module: "edges",
-      functionName: "findContradictions",
+      module: "contextCompiler",
+      functionName: "listGraphIntelligenceQueries",
+      kind: "query"
+    },
+    args: graphIntelligenceCatalogArgs
+  }),
+  surfaceContract({
+    name: "run_graph_intelligence_query",
+    kind: "query",
+    domain: "graph",
+    surfaceClass: "platform_public",
+    path: "/graph-intelligence/run",
+    sdkNamespace: "graphAnalysis",
+    sdkMethod: "runGraphIntelligenceQuery",
+    summary: "Run a Graph Intelligence query against a topic graph.",
+    convex: {
+      module: "contextCompiler",
+      functionName: "runGraphIntelligenceQuery",
+      kind: "query"
+    },
+    args: graphIntelligenceRunArgs
+  }),
+  surfaceContract({
+    name: "find_contradictions",
+    kind: "query",
+    domain: "graph",
+    surfaceClass: "platform_public",
+    path: "/graph/contradictions",
+    sdkNamespace: "graph",
+    sdkMethod: "findContradictions",
+    summary: "Find contradiction edges.",
+    convex: {
+      module: "edges",
+      functionName: "findContradictions",
       kind: "query",
       inputProjection: (input) => compactRecord4({
         nodeId: input.nodeId ?? input.beliefId
@@ -13594,6 +14469,353 @@ function scoreObservation(record, terms) {
   return score;
 }
 
+// ../sdk/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ACTIVATE_WORKTREE: () => ACTIVATE_WORKTREE,
+  ADD_EVIDENCE: () => ADD_EVIDENCE,
+  ADD_WORKTREE: () => ADD_WORKTREE,
+  ANALYZE_TOPIC_DENSITY: () => ANALYZE_TOPIC_DENSITY,
+  ANSWER_QUESTION: () => ANSWER_QUESTION,
+  APPLY_AUTO_BRANCHING: () => APPLY_AUTO_BRANCHING,
+  APPLY_LENS_TO_TOPIC: () => APPLY_LENS_TO_TOPIC,
+  APPLY_ONTOLOGY: () => APPLY_ONTOLOGY,
+  ARCHIVE_BELIEF: () => ARCHIVE_BELIEF,
+  ARCHIVE_ONTOLOGY: () => ARCHIVE_ONTOLOGY,
+  ARCHIVE_QUESTION: () => ARCHIVE_QUESTION,
+  BEGIN_BUILD_SESSION: () => BEGIN_BUILD_SESSION,
+  BELIEF_STATUSES: () => BELIEF_STATUSES,
+  BISECT_CONFIDENCE: () => BISECT_CONFIDENCE,
+  BRANCH_DEPRECATION_MESSAGE: () => BRANCH_DEPRECATION_MESSAGE,
+  BROADCAST_MESSAGE: () => BROADCAST_MESSAGE,
+  CANONICAL_WORKFLOW_DEFINITIONS: () => CANONICAL_WORKFLOW_DEFINITIONS,
+  CHECK_PERMISSION: () => CHECK_PERMISSION,
+  CLAIM_FILES: () => CLAIM_FILES,
+  COMPILE_CONTEXT: () => COMPILE_CONTEXT,
+  COMPLETE_TASK: () => COMPLETE_TASK,
+  CONFIDENCE_TRIGGERS: () => CONFIDENCE_TRIGGERS,
+  CONTRADICTION_SEVERITIES: () => CONTRADICTION_SEVERITIES,
+  CONTRADICTION_STATUSES: () => CONTRADICTION_STATUSES,
+  CONTROL_OBJECT_BLAST_RADII: () => CONTROL_OBJECT_BLAST_RADII,
+  CONTROL_OBJECT_EDIT_SURFACES: () => CONTROL_OBJECT_EDIT_SURFACES,
+  CONTROL_OBJECT_INHERITANCE_RULES: () => CONTROL_OBJECT_INHERITANCE_RULES,
+  CONTROL_OBJECT_KINDS: () => CONTROL_OBJECT_KINDS,
+  CONTROL_OBJECT_OWNERSHIP_CONTRACT: () => CONTROL_OBJECT_OWNERSHIP_CONTRACT,
+  CONTROL_OBJECT_OWNERSHIP_MATRIX: () => CONTROL_OBJECT_OWNERSHIP_MATRIX,
+  CONTROL_OBJECT_OWNERSHIP_ROWS: () => CONTROL_OBJECT_OWNERSHIP_ROWS,
+  CONTROL_OBJECT_OWNER_SCOPES: () => CONTROL_OBJECT_OWNER_SCOPES,
+  CREATE_ANSWER: () => CREATE_ANSWER,
+  CREATE_BELIEF: () => CREATE_BELIEF,
+  CREATE_EDGE: () => CREATE_EDGE,
+  CREATE_EPISTEMIC_CONTRACT: () => CREATE_EPISTEMIC_CONTRACT,
+  CREATE_EVIDENCE: () => CREATE_EVIDENCE,
+  CREATE_LENS: () => CREATE_LENS,
+  CREATE_ONTOLOGY: () => CREATE_ONTOLOGY,
+  CREATE_ONTOLOGY_VERSION: () => CREATE_ONTOLOGY_VERSION,
+  CREATE_QUESTION: () => CREATE_QUESTION,
+  CREATE_TASK: () => CREATE_TASK,
+  CREATE_TOPIC: () => CREATE_TOPIC,
+  CustomToolRegistryError: () => CustomToolRegistryError,
+  DEFAULT_TIER_APPROVAL_MODE: () => DEFAULT_TIER_APPROVAL_MODE,
+  DEFAULT_WORKFLOW_AUTO_FIX_POLICY: () => DEFAULT_WORKFLOW_AUTO_FIX_POLICY,
+  DEFEAT_TYPES: () => DEFEAT_TYPES,
+  DEPRECATE_ONTOLOGY_VERSION: () => DEPRECATE_ONTOLOGY_VERSION,
+  DETECT_CONFIRMATION_BIAS: () => DETECT_CONFIRMATION_BIAS,
+  DISCOVER: () => DISCOVER,
+  DISCOVER_ENTITY_CONNECTIONS: () => DISCOVER_ENTITY_CONNECTIONS,
+  DOMAIN_EVENT_TYPES: () => DOMAIN_EVENT_TYPES,
+  DOMAIN_EVENT_VERSION: () => DOMAIN_EVENT_VERSION,
+  DeviceAuthorizationError: () => DeviceAuthorizationError,
+  EDGE_TYPES: () => EDGE_TYPES,
+  EMBEDDINGS_FIELDS: () => EMBEDDINGS_FIELDS,
+  END_SESSION: () => END_SESSION,
+  EPISTEMIC_EDGE_TYPES: () => EPISTEMIC_EDGE_TYPES,
+  EPISTEMIC_LAYERS: () => EPISTEMIC_LAYERS,
+  EVALUATE_CONTRACT: () => EVALUATE_CONTRACT,
+  EVENTING_FIELDS: () => EVENTING_FIELDS,
+  EVENT_RETENTION_DEFAULT_DAYS: () => EVENT_RETENTION_DEFAULT_DAYS,
+  FILTER_BY_PERMISSION: () => FILTER_BY_PERMISSION,
+  FIND_CONTRADICTIONS: () => FIND_CONTRADICTIONS,
+  FIND_MISSING_QUESTIONS: () => FIND_MISSING_QUESTIONS,
+  FLAG_CONTRADICTION: () => FLAG_CONTRADICTION,
+  FORK_BELIEF: () => FORK_BELIEF,
+  FORK_REASONS: () => FORK_REASONS,
+  FUNCTION_SURFACE_METHOD_PATHS: () => FUNCTION_SURFACE_METHOD_PATHS,
+  GENERATE_SESSION_HANDOFF: () => GENERATE_SESSION_HANDOFF,
+  GET_AGENT_INBOX: () => GET_AGENT_INBOX,
+  GET_ANSWER: () => GET_ANSWER,
+  GET_AUDIT_TRAIL: () => GET_AUDIT_TRAIL,
+  GET_BELIEF: () => GET_BELIEF,
+  GET_CHANGE_HISTORY: () => GET_CHANGE_HISTORY,
+  GET_CODE_CONTEXT: () => GET_CODE_CONTEXT,
+  GET_CONFIDENCE_HISTORY: () => GET_CONFIDENCE_HISTORY,
+  GET_CONTRACT_STATUS: () => GET_CONTRACT_STATUS,
+  GET_EVIDENCE: () => GET_EVIDENCE,
+  GET_FAILURE_LOG: () => GET_FAILURE_LOG,
+  GET_FALSIFICATION_QUESTIONS: () => GET_FALSIFICATION_QUESTIONS,
+  GET_GRAPH_GAPS: () => GET_GRAPH_GAPS,
+  GET_GRAPH_NEIGHBORHOOD: () => GET_GRAPH_NEIGHBORHOOD,
+  GET_GRAPH_STRUCTURE_ANALYSIS: () => GET_GRAPH_STRUCTURE_ANALYSIS,
+  GET_HIGH_PRIORITY_QUESTIONS: () => GET_HIGH_PRIORITY_QUESTIONS,
+  GET_LATTICE_COVERAGE: () => GET_LATTICE_COVERAGE,
+  GET_OBSERVATION_CONTEXT: () => GET_OBSERVATION_CONTEXT,
+  GET_ONTOLOGY: () => GET_ONTOLOGY,
+  GET_QUESTION: () => GET_QUESTION,
+  GET_TOPIC: () => GET_TOPIC,
+  GET_TOPIC_COVERAGE: () => GET_TOPIC_COVERAGE,
+  GET_TOPIC_TREE: () => GET_TOPIC_TREE,
+  GIT_SEMANTIC_REQUIRED_TOOLS: () => GIT_SEMANTIC_REQUIRED_TOOLS,
+  GRAPH_ANALYSIS_ANALYSIS_FIELDS: () => GRAPH_ANALYSIS_ANALYSIS_FIELDS,
+  GRAPH_ANALYSIS_COMPUTE_FIELDS: () => GRAPH_ANALYSIS_COMPUTE_FIELDS,
+  GRAPH_ANALYSIS_SUGGESTION_FIELDS: () => GRAPH_ANALYSIS_SUGGESTION_FIELDS,
+  GRAPH_INTELLIGENCE_MODE_TOOL_NAMES: () => GRAPH_INTELLIGENCE_MODE_TOOL_NAMES,
+  GRAPH_INTELLIGENCE_PUBLIC_TOOL_NAMES: () => GRAPH_INTELLIGENCE_PUBLIC_TOOL_NAMES,
+  GRAPH_INTELLIGENCE_QUERIES: () => GRAPH_INTELLIGENCE_QUERIES,
+  GRAPH_INTELLIGENCE_QUERIES_WITH_TOOLS: () => GRAPH_INTELLIGENCE_QUERIES_WITH_TOOLS,
+  GRAPH_INTELLIGENCE_QUERY_CATALOG_VERSION: () => GRAPH_INTELLIGENCE_QUERY_CATALOG_VERSION,
+  GRAPH_INTELLIGENCE_QUERY_CATEGORIES: () => GRAPH_INTELLIGENCE_QUERY_CATEGORIES,
+  GRAPH_INTELLIGENCE_QUERY_MODES: () => GRAPH_INTELLIGENCE_QUERY_MODES,
+  GRAPH_INTELLIGENCE_QUICK_QUERIES: () => GRAPH_INTELLIGENCE_QUICK_QUERIES,
+  GRAPH_RECOMMENDATION_FIELDS: () => GRAPH_RECOMMENDATION_FIELDS,
+  GRAPH_STATE_CLASSIFIER_FIELDS: () => GRAPH_STATE_CLASSIFIER_FIELDS,
+  HEARTBEAT_SESSION: () => HEARTBEAT_SESSION,
+  IDENTITY_WHOAMI: () => IDENTITY_WHOAMI,
+  INGEST_OBSERVATION: () => INGEST_OBSERVATION,
+  InfisicalRuntimeError: () => InfisicalRuntimeError,
+  JOBS_FIELDS: () => JOBS_FIELDS,
+  JUDGMENT_TYPES: () => JUDGMENT_TYPES,
+  LENS_PERSPECTIVE_TYPES: () => LENS_PERSPECTIVE_TYPES2,
+  LENS_STATUSES: () => LENS_STATUSES,
+  LENS_TASK_TEMPLATE_PRIORITIES: () => LENS_TASK_TEMPLATE_PRIORITIES,
+  LINK_EVIDENCE: () => LINK_EVIDENCE,
+  LINK_EVIDENCE_TO_BELIEF: () => LINK_EVIDENCE_TO_BELIEF,
+  LINK_EVIDENCE_TO_QUESTION: () => LINK_EVIDENCE_TO_QUESTION,
+  LIST_ACTIVE_SESSIONS: () => LIST_ACTIVE_SESSIONS,
+  LIST_ALL_WORKTREES: () => LIST_ALL_WORKTREES,
+  LIST_BELIEFS: () => LIST_BELIEFS,
+  LIST_CAMPAIGNS: () => LIST_CAMPAIGNS,
+  LIST_EVIDENCE: () => LIST_EVIDENCE,
+  LIST_GRAPH_INTELLIGENCE_QUERIES: () => LIST_GRAPH_INTELLIGENCE_QUERIES,
+  LIST_LENSES: () => LIST_LENSES,
+  LIST_ONTOLOGIES: () => LIST_ONTOLOGIES,
+  LIST_QUESTIONS: () => LIST_QUESTIONS,
+  LIST_TASKS: () => LIST_TASKS,
+  LIST_TOPICS: () => LIST_TOPICS,
+  LIST_WORKTREES: () => LIST_WORKTREES,
+  LUCERN_SDK_VERSION: () => LUCERN_SDK_VERSION,
+  LucernApiError: () => LucernApiError,
+  LucernSdkAuthContextError: () => LucernSdkAuthContextError,
+  MANAGE_WRITE_POLICY: () => MANAGE_WRITE_POLICY,
+  MATCH_ENTITY_TYPE: () => MATCH_ENTITY_TYPE,
+  MAX_ENTITY_LIMIT: () => MAX_ENTITY_LIMIT,
+  MCP_ALWAYS_ALLOWED_TOOL_NAMES: () => MCP_ALWAYS_ALLOWED_TOOL_NAMES,
+  MCP_TOOL_CONTRACTS: () => MCP_TOOL_CONTRACTS,
+  MERGE: () => MERGE,
+  MERGE_OUTCOMES: () => MERGE_OUTCOMES,
+  MODEL_RUNTIME_FIELDS: () => MODEL_RUNTIME_FIELDS,
+  MODULATE_CONFIDENCE: () => MODULATE_CONFIDENCE,
+  MORNING_BRIEF_WORKFLOW_ID: () => MORNING_BRIEF_WORKFLOW_ID,
+  NIGHTLY_RECONCILIATION_WORKFLOW_ID: () => NIGHTLY_RECONCILIATION_WORKFLOW_ID,
+  ONTOLOGY_LINK_FIELDS: () => ONTOLOGY_LINK_FIELDS,
+  OPEN_PULL_REQUEST: () => OPEN_PULL_REQUEST,
+  ORG_GRAPH_SEARCH_FIELDS: () => ORG_GRAPH_SEARCH_FIELDS,
+  PIPELINE_SNAPSHOT: () => PIPELINE_SNAPSHOT,
+  PUBLISH_ONTOLOGY_VERSION: () => PUBLISH_ONTOLOGY_VERSION,
+  PUSH: () => PUSH,
+  QUERY_LINEAGE: () => QUERY_LINEAGE,
+  REASONING_METHODS: () => REASONING_METHODS,
+  RECORD_ATTEMPT: () => RECORD_ATTEMPT,
+  RECORD_JUDGMENT: () => RECORD_JUDGMENT,
+  RECORD_SCOPE_LEARNING: () => RECORD_SCOPE_LEARNING,
+  REFINE_BELIEF: () => REFINE_BELIEF,
+  REFINE_QUESTION: () => REFINE_QUESTION,
+  REGISTER_SESSION: () => REGISTER_SESSION,
+  REMOVE_LENS_FROM_TOPIC: () => REMOVE_LENS_FROM_TOPIC,
+  RESOLVE_EFFECTIVE_ONTOLOGY: () => RESOLVE_EFFECTIVE_ONTOLOGY,
+  RUN_GRAPH_INTELLIGENCE_QUERY: () => RUN_GRAPH_INTELLIGENCE_QUERY,
+  SEARCH_BELIEFS: () => SEARCH_BELIEFS,
+  SEARCH_EVIDENCE: () => SEARCH_EVIDENCE,
+  SEED_BELIEF_LATTICE: () => SEED_BELIEF_LATTICE,
+  SEND_AGENT_MESSAGE: () => SEND_AGENT_MESSAGE,
+  SESSION_AUTH_MODES: () => SESSION_AUTH_MODES,
+  SESSION_LIFECYCLE_STATUSES: () => SESSION_LIFECYCLE_STATUSES,
+  SESSION_PRINCIPAL_TYPES: () => SESSION_PRINCIPAL_TYPES,
+  STRUCTURAL_EDGE_TYPES: () => STRUCTURAL_EDGE_TYPES,
+  TELEMETRY_FIELDS: () => TELEMETRY_FIELDS,
+  TENANT_IDENTITY_FIELDS: () => TENANT_IDENTITY_FIELDS,
+  TOOL_REGISTRY_FIELDS: () => TOOL_REGISTRY_FIELDS,
+  TRACE_ENTITY_IMPACT: () => TRACE_ENTITY_IMPACT,
+  TRAVERSE_GRAPH: () => TRAVERSE_GRAPH,
+  TRIGGER_BELIEF_REVIEW: () => TRIGGER_BELIEF_REVIEW,
+  UPDATE_ONTOLOGY: () => UPDATE_ONTOLOGY,
+  UPDATE_QUESTION_STATUS: () => UPDATE_QUESTION_STATUS,
+  UPDATE_TASK: () => UPDATE_TASK,
+  UPDATE_TOPIC: () => UPDATE_TOPIC,
+  UPDATE_WORKTREE_METADATA: () => UPDATE_WORKTREE_METADATA,
+  UPDATE_WORKTREE_TARGETS: () => UPDATE_WORKTREE_TARGETS,
+  WEBHOOK_MAX_ATTEMPTS: () => WEBHOOK_MAX_ATTEMPTS,
+  WEBHOOK_RETRY_DELAYS_MS: () => WEBHOOK_RETRY_DELAYS_MS,
+  WORKFLOW_ACTION_KINDS: () => WORKFLOW_ACTION_KINDS,
+  WORKFLOW_APPROVAL_MODES: () => WORKFLOW_APPROVAL_MODES,
+  WORKFLOW_AUTO_FIX_MODES: () => WORKFLOW_AUTO_FIX_MODES,
+  WORKFLOW_HOOK_EVENTS: () => WORKFLOW_HOOK_EVENTS,
+  WORKFLOW_INTEGRITY_CHECKS: () => WORKFLOW_INTEGRITY_CHECKS,
+  WORKFLOW_MUTATION_TIERS: () => WORKFLOW_MUTATION_TIERS,
+  WORKFLOW_OUTPUT_KINDS: () => WORKFLOW_OUTPUT_KINDS,
+  WORKFLOW_PROOF_ARTIFACT_KINDS: () => WORKFLOW_PROOF_ARTIFACT_KINDS,
+  WORKFLOW_RUNTIME_SCHEMA_VERSION: () => WORKFLOW_RUNTIME_SCHEMA_VERSION,
+  WORKFLOW_RUN_STATUSES: () => WORKFLOW_RUN_STATUSES,
+  WORKFLOW_STAFFING_HINTS: () => WORKFLOW_STAFFING_HINTS,
+  WORKFLOW_TRIGGER_KINDS: () => WORKFLOW_TRIGGER_KINDS,
+  WORKTREE_PHASES: () => WORKTREE_PHASES,
+  applyInfisicalRuntimeEnv: () => applyInfisicalRuntimeEnv,
+  asListItems: () => asListItems,
+  assertValidWebhookSecret: () => assertValidWebhookSecret,
+  assertValidWebhookUrl: () => assertValidWebhookUrl,
+  buildDeprecatedBranchMetadata: () => buildDeprecatedBranchMetadata,
+  buildDomainEvent: () => buildDomainEvent,
+  buildMcpToolContracts: () => buildMcpToolContracts,
+  buildMcpToolManifest: () => buildMcpToolManifest,
+  clearRegisteredCustomTools: () => clearRegisteredCustomTools,
+  compareEventCursor: () => compareEventCursor,
+  compileContextPackFromSnapshot: () => compileContextPackFromSnapshot,
+  computeWebhookSignature: () => computeWebhookSignature,
+  createAdminClient: () => createAdminClient,
+  createAnswersClient: () => createAnswersClient,
+  createAudiencesClient: () => createAudiencesClient,
+  createAuditClient: () => createAuditClient,
+  createAuthDeviceClient: () => createAuthDeviceClient,
+  createBeliefsClient: () => createBeliefsClient,
+  createCanonicalAuthHeaders: () => createCanonicalAuthHeaders,
+  createContextClient: () => createContextClient,
+  createContextFacade: () => createContextFacade,
+  createDecisionsClient: () => createDecisionsClient,
+  createEmbeddingsClient: () => createEmbeddingsClient,
+  createEventId: () => createEventId,
+  createEventingClient: () => createEventingClient,
+  createEventsClientCore: () => createEventsClientCore,
+  createEvidenceClient: () => createEvidenceClient,
+  createFunctionSurfaceClient: () => createFunctionSurfaceClient,
+  createGatewayRequestClient: () => createGatewayRequestClient,
+  createGraphAnalysisClient: () => createGraphAnalysisClient,
+  createGraphClient: () => createGraphClient,
+  createGraphRecommendationsClient: () => createGraphRecommendationsClient,
+  createGraphStateClassifierClient: () => createGraphStateClassifierClient,
+  createHarnessClient: () => createHarnessClient,
+  createIdentityClient: () => createIdentityClient,
+  createJobsClient: () => createJobsClient,
+  createLearningClient: () => createLearningClient,
+  createListResult: () => createListResult,
+  createLucernClient: () => createLucernClient,
+  createModelRuntimeClient: () => createModelRuntimeClient,
+  createOntologyClient: () => createOntologyClient,
+  createOntologyLinksClient: () => createOntologyLinksClient,
+  createOrgGraphSearchClient: () => createOrgGraphSearchClient,
+  createPacksClient: () => createPacksClient,
+  createPolicyClient: () => createPolicyClient,
+  createReportsClient: () => createReportsClient,
+  createSchemaClient: () => createSchemaClient,
+  createSourcesClient: () => createSourcesClient,
+  createTelemetryClient: () => createTelemetryClient,
+  createToolRegistryClient: () => createToolRegistryClient,
+  createTopicsClient: () => createTopicsClient,
+  createWebhooksClientCore: () => createWebhooksClientCore,
+  createWorkflowClient: () => createWorkflowClient,
+  decodeEventCursor: () => decodeEventCursor,
+  emitDomainEvent: () => emitDomainEvent,
+  encodeEventCursor: () => encodeEventCursor,
+  eventPatternToRegExp: () => eventPatternToRegExp,
+  fillGraphIntelligencePromptTemplate: () => fillGraphIntelligencePromptTemplate,
+  getControlObjectOwnershipCase: () => getControlObjectOwnershipCase,
+  getGraphIntelligenceQuery: () => getGraphIntelligenceQuery,
+  getMcpToolExposure: () => getMcpToolExposure,
+  getRegisteredCustomTool: () => getRegisteredCustomTool,
+  hydrateInfisicalRuntimeEnv: () => hydrateInfisicalRuntimeEnv,
+  inferActorType: () => inferActorType,
+  inferLensPerspectiveTypeFromBranchSchema: () => inferLensPerspectiveTypeFromBranchSchema,
+  inferSessionPrincipalType: () => inferSessionPrincipalType,
+  invokeRegisteredCustomTool: () => invokeRegisteredCustomTool,
+  isAfterCursor: () => isAfterCursor,
+  isGraphIntelligenceQueryMode: () => isGraphIntelligenceQueryMode,
+  isInfisicalRuntimeDisabled: () => isInfisicalRuntimeDisabled,
+  isLensFilterCriteria: () => isLensFilterCriteria2,
+  isLucernPrompt: () => isLucernPrompt,
+  isMcpToolAllowed: () => isMcpToolAllowed,
+  isTaxonomyFilterCriteriaV1: () => isTaxonomyFilterCriteriaV12,
+  lastDelegator: () => lastDelegator,
+  listControlObjectOwnershipCases: () => listControlObjectOwnershipCases,
+  listGraphIntelligenceQueries: () => listGraphIntelligenceQueries,
+  listRegisteredCustomTools: () => listRegisteredCustomTools,
+  mapAliasedList: () => mapAliasedList,
+  mapGatewayData: () => mapGatewayData,
+  mapOpinionHistoryEntriesFromGatewayData: () => mapOpinionHistoryEntriesFromGatewayData,
+  matchesAnyEventPattern: () => matchesAnyEventPattern,
+  matchesEventPattern: () => matchesEventPattern,
+  mcpContractToInputSchema: () => mcpContractToInputSchema,
+  mcpContractToManifestEntry: () => mcpContractToManifestEntry,
+  migrateBranchToLens: () => migrateBranchToLens,
+  nextDeliveryAttemptAt: () => nextDeliveryAttemptAt,
+  normalizeCanonicalLucernAuthContext: () => normalizeCanonicalLucernAuthContext,
+  normalizeDelegationChain: () => normalizeDelegationChain,
+  normalizeNodeVerificationStatus: () => normalizeNodeVerificationStatus,
+  normalizeNodeWriteInput: () => normalizeNodeWriteInput,
+  normalizeRetentionDays: () => normalizeRetentionDays,
+  normalizeTopicQuery: () => normalizeTopicQuery,
+  normalizeWebhookPatterns: () => normalizeWebhookPatterns,
+  opinionFromBaseRate: () => opinionFromBaseRate,
+  opinionFromDogmatic: () => opinionFromDogmatic,
+  opinionFromProjected: () => opinionFromProjected,
+  planContextPackCompilation: () => planContextPackCompilation,
+  randomIdempotencyKey: () => randomIdempotencyKey,
+  readInfisicalRuntimeBootstrap: () => readInfisicalRuntimeBootstrap,
+  registerCustomTool: () => registerCustomTool,
+  resolveDeliveryFailureStatus: () => resolveDeliveryFailureStatus,
+  resolveText: () => resolveText,
+  resolveTopicId: () => resolveTopicId,
+  sanitizeWebhookRecord: () => sanitizeWebhookRecord,
+  sortEventsByCursor: () => sortEventsByCursor,
+  toQueryString: () => toQueryString,
+  truncateWebhookResponseBody: () => truncateWebhookResponseBody,
+  unregisterCustomTool: () => unregisterCustomTool,
+  validateFilterCriteria: () => validateFilterCriteria2,
+  validateGitSemantics: () => validateGitSemantics,
+  withSdkAliases: () => withSdkAliases,
+  withTextAlias: () => withTextAlias,
+  withTopicAlias: () => withTopicAlias
+});
+
+// ../sdk/src/opinion.ts
+function clamp01(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(1, value));
+}
+function vacuous(baseRate) {
+  return { b: 0, d: 0, u: 1, a: clamp01(baseRate) };
+}
+function dogmatic(probability, baseRate) {
+  const p = clamp01(probability);
+  return { b: p, d: 1 - p, u: 0, a: clamp01(baseRate) };
+}
+function opinionFromBaseRate(probability) {
+  return vacuous(clamp01(probability));
+}
+function opinionFromDogmatic(probability, baseRate) {
+  return dogmatic(clamp01(probability), clamp01(baseRate));
+}
+function opinionFromProjected(probability, uncertainty, baseRate) {
+  const p = clamp01(probability);
+  const u = clamp01(uncertainty);
+  const remainingMass = 1 - u;
+  return {
+    b: p * remainingMass,
+    d: (1 - p) * remainingMass,
+    u,
+    a: clamp01(baseRate)
+  };
+}
+
 // ../sdk/src/authContext.ts
 var LucernSdkAuthContextError = class extends Error {
   reason;
@@ -14902,7 +16124,7 @@ function readString2(value) {
 function readNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function clamp01(value) {
+function clamp012(value) {
   return Math.max(0, Math.min(1, value));
 }
 function normalizeOpinionTuple(record) {
@@ -14917,10 +16139,10 @@ function normalizeOpinionTuple(record) {
     );
   }
   return {
-    b: clamp01(rawBelief),
-    d: clamp01(rawDisbelief),
-    u: clamp01(rawUncertainty),
-    a: clamp01(rawBaseRate)
+    b: clamp012(rawBelief),
+    d: clamp012(rawDisbelief),
+    u: clamp012(rawUncertainty),
+    a: clamp012(rawBaseRate)
   };
 }
 function mapOpinionHistoryEntriesFromGatewayData(payload) {
@@ -14928,7 +16150,7 @@ function mapOpinionHistoryEntriesFromGatewayData(payload) {
   return entries2.map((value) => {
     const record = asRecord2(value);
     const tuple = normalizeOpinionTuple(record);
-    const projected = readNumber(record.confidence) ?? clamp01(tuple.b + tuple.a * tuple.u);
+    const projected = readNumber(record.confidence) ?? clamp012(tuple.b + tuple.a * tuple.u);
     const triggeringEvidenceId = readString2(record.triggeringEvidenceId);
     const triggeringQuestionId = readString2(record.triggeringQuestionId);
     const triggeringAnswerId = readString2(record.triggeringAnswerId);
@@ -14947,7 +16169,7 @@ function mapOpinionHistoryEntriesFromGatewayData(payload) {
       d: tuple.d,
       u: tuple.u,
       a: tuple.a,
-      P: clamp01(projected),
+      P: clamp012(projected),
       trigger,
       ...triggeringRef ? { triggeringRef } : {},
       ...readString2(record.rationale) ? { rationale: readString2(record.rationale) } : {},
@@ -17709,9 +18931,33 @@ function graphAnalysisQuery(input) {
     cursor: input.cursor
   };
 }
+function normalizeRunQueryPayload(input) {
+  return {
+    ...input,
+    topicId: requireTopicId2(input),
+    projectId: void 0
+  };
+}
 function createGraphAnalysisClient(config = {}) {
   const gateway = createGatewayRequestClient(config);
   return {
+    listGraphIntelligenceQueries(input = {}) {
+      return gateway.request({
+        path: "/api/platform/v1/graph-intelligence/queries",
+        method: "POST",
+        body: {
+          categoryId: input.categoryId,
+          mode: input.mode
+        }
+      });
+    },
+    runGraphIntelligenceQuery(input) {
+      return gateway.request({
+        path: "/api/platform/v1/graph-intelligence/run",
+        method: "POST",
+        body: normalizeRunQueryPayload(input)
+      });
+    },
     saveAnalysis(input, idempotencyKey) {
       return gateway.request({
         path: "/api/platform/v1/graph-analysis/analyses",
@@ -18548,6 +19794,120 @@ function createMcpClient(config = {}) {
 }
 
 // ../sdk/src/generated/functionSurface.ts
+var FUNCTION_SURFACE_METHOD_PATHS = [
+  "answers.answerQuestion",
+  "answers.createAnswer",
+  "answers.getAnswer",
+  "beliefs.archiveBelief",
+  "beliefs.bisectConfidence",
+  "beliefs.createBelief",
+  "beliefs.forkBelief",
+  "beliefs.getBelief",
+  "beliefs.getConfidenceHistory",
+  "beliefs.listBeliefs",
+  "beliefs.modulateConfidence",
+  "beliefs.refineBelief",
+  "beliefs.searchBeliefs",
+  "bootstrap.generateSessionHandoff",
+  "coding.getChangeHistory",
+  "coding.getCodeContext",
+  "coding.getFailureLog",
+  "coding.recordAttempt",
+  "context.analyzeTopicDensity",
+  "context.applyAutoBranching",
+  "context.compileContext",
+  "context.discover",
+  "context.discoverEntityConnections",
+  "context.getLatticeCoverage",
+  "context.recordScopeLearning",
+  "context.seedBeliefLattice",
+  "context.triggerBeliefReview",
+  "contracts.createEpistemicContract",
+  "contracts.evaluateContract",
+  "contracts.getContractStatus",
+  "contradictions.flagContradiction",
+  "coordination.broadcastMessage",
+  "coordination.claimFiles",
+  "coordination.endSession",
+  "coordination.getAgentInbox",
+  "coordination.heartbeatSession",
+  "coordination.listActiveSessions",
+  "coordination.registerSession",
+  "coordination.sendAgentMessage",
+  "edges.createEdge",
+  "edges.queryLineage",
+  "evidence.addEvidence",
+  "evidence.createEvidence",
+  "evidence.getEvidence",
+  "evidence.linkEvidence",
+  "evidence.linkEvidenceToBelief",
+  "evidence.linkEvidenceToQuestion",
+  "evidence.listEvidence",
+  "evidence.searchEvidence",
+  "graph.detectConfirmationBias",
+  "graph.findContradictions",
+  "graph.getGraphGaps",
+  "graph.getGraphNeighborhood",
+  "graph.getGraphStructureAnalysis",
+  "graph.getTopicCoverage",
+  "graph.traceEntityImpact",
+  "graph.traverseGraph",
+  "graphAnalysis.listGraphIntelligenceQueries",
+  "graphAnalysis.runGraphIntelligenceQuery",
+  "identity.checkPermission",
+  "identity.filterByPermission",
+  "identity.whoami",
+  "judgments.getAuditTrail",
+  "judgments.recordJudgment",
+  "lenses.applyLensToTopic",
+  "lenses.createLens",
+  "lenses.listLenses",
+  "lenses.removeLensFromTopic",
+  "observations.getObservationContext",
+  "observations.ingestObservation",
+  "ontologies.applyOntology",
+  "ontologies.archiveOntology",
+  "ontologies.createOntology",
+  "ontologies.createOntologyVersion",
+  "ontologies.deprecateOntologyVersion",
+  "ontologies.getOntology",
+  "ontologies.listOntologies",
+  "ontologies.matchEntityType",
+  "ontologies.publishOntologyVersion",
+  "ontologies.resolveEffectiveOntology",
+  "ontologies.updateOntology",
+  "policy.manageWritePolicy",
+  "questions.archiveQuestion",
+  "questions.createQuestion",
+  "questions.findMissingQuestions",
+  "questions.getFalsificationQuestions",
+  "questions.getHighPriorityQuestions",
+  "questions.getQuestion",
+  "questions.listQuestions",
+  "questions.refineQuestion",
+  "questions.updateQuestionStatus",
+  "tasks.completeTask",
+  "tasks.createTask",
+  "tasks.listTasks",
+  "tasks.updateTask",
+  "topics.createTopic",
+  "topics.getTopic",
+  "topics.getTopicTree",
+  "topics.listTopics",
+  "topics.updateTopic",
+  "worktrees.activateWorktree",
+  "worktrees.addWorktree",
+  "worktrees.beginBuildSession",
+  "worktrees.listAllWorktrees",
+  "worktrees.listCampaigns",
+  "worktrees.listWorktrees",
+  "worktrees.merge",
+  "worktrees.openPullRequest",
+  "worktrees.pipelineSnapshot",
+  "worktrees.push",
+  "worktrees.updateWorktreeMetadata",
+  "worktrees.updateWorktreeTargets"
+];
 var CONTRACTS = {
   "activate_worktree": { method: "POST", path: "/worktrees/activate", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
   "add_evidence": { method: "POST", path: "/evidence/add", kind: "mutation", idempotent: true, surfaceIntent: "compatibility" },
@@ -18623,6 +19983,7 @@ var CONTRACTS = {
   "list_beliefs": { method: "GET", path: "/beliefs", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
   "list_campaigns": { method: "GET", path: "/worktrees/campaigns", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
   "list_evidence": { method: "GET", path: "/evidence", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
+  "list_graph_intelligence_queries": { method: "POST", path: "/graph-intelligence/queries", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
   "list_lenses": { method: "GET", path: "/lenses", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
   "list_ontologies": { method: "GET", path: "/ontologies", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
   "list_questions": { method: "GET", path: "/questions", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
@@ -18646,6 +20007,7 @@ var CONTRACTS = {
   "register_session": { method: "POST", path: "/coordination/register-session", kind: "mutation", idempotent: true, surfaceIntent: "system" },
   "remove_lens_from_topic": { method: "DELETE", path: "/lenses/apply", kind: "mutation", idempotent: true, surfaceIntent: "mcp_workflow" },
   "resolve_effective_ontology": { method: "POST", path: "/ontologies/effective", kind: "query", idempotent: false, surfaceIntent: "mcp_workflow" },
+  "run_graph_intelligence_query": { method: "POST", path: "/graph-intelligence/run", kind: "query", idempotent: false, surfaceIntent: "mcp_analysis" },
   "search_beliefs": { method: "POST", path: "/beliefs/search", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
   "search_evidence": { method: "POST", path: "/evidence/search", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
   "seed_belief_lattice": { method: "POST", path: "/scope/belief-lattice/seed", kind: "mutation", idempotent: true, surfaceIntent: "system" },
@@ -18921,6 +20283,9 @@ function createFunctionSurfaceClient(config = {}) {
     listEvidence(input = {}, idempotencyKey) {
       return execute("list_evidence", input, idempotencyKey);
     },
+    listGraphIntelligenceQueries(input = {}, idempotencyKey) {
+      return execute("list_graph_intelligence_queries", input, idempotencyKey);
+    },
     listLenses(input = {}, idempotencyKey) {
       return execute("list_lenses", input, idempotencyKey);
     },
@@ -18990,6 +20355,9 @@ function createFunctionSurfaceClient(config = {}) {
     resolveEffectiveOntology(input = {}, idempotencyKey) {
       return execute("resolve_effective_ontology", input, idempotencyKey);
     },
+    runGraphIntelligenceQuery(input = {}, idempotencyKey) {
+      return execute("run_graph_intelligence_query", input, idempotencyKey);
+    },
     searchBeliefs(input = {}, idempotencyKey) {
       return execute("search_beliefs", input, idempotencyKey);
     },
@@ -22591,198 +23959,2367 @@ function createLucernClient(config = {}) {
   };
 }
 
-// ../sdk/src/controlObjectOwnership.ts
-var CONTROL_OBJECT_KINDS = [
-  "tenant",
-  "workspace",
-  "principal",
-  "tool",
-  "pack",
-  "ontology",
-  "belief",
-  "policy_rule"
-];
-function defineCases(cases) {
-  return cases;
+// ../sdk/src/facade/context.ts
+function cleanString6(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
-var CONTROL_OBJECT_OWNERSHIP_MATRIX = {
-  tenant: defineCases([
-    {
-      caseKey: "platform-record",
-      caseLabel: "Platform Record",
-      kind: "tenant",
-      canonicalOwnerScope: "platform",
-      editSurface: "platform_admin",
-      inheritanceRule: "none",
-      blastRadius: "tenant"
-    }
-  ]),
-  workspace: defineCases([
-    {
-      caseKey: "tenant-workspace",
-      caseLabel: "Tenant Workspace",
-      kind: "workspace",
-      canonicalOwnerScope: "tenant",
-      editSurface: "tenant_admin",
-      inheritanceRule: "tenant_default_to_workspace",
-      blastRadius: "workspace"
-    }
-  ]),
-  principal: defineCases([
-    {
-      caseKey: "tenant-principal",
-      caseLabel: "Tenant Principal",
-      kind: "principal",
-      canonicalOwnerScope: "tenant",
-      editSurface: "tenant_admin",
-      inheritanceRule: "workspace_narrowing_only",
-      blastRadius: "resource"
-    }
-  ]),
-  tool: defineCases([
-    {
-      caseKey: "platform-core",
-      caseLabel: "Platform Core",
-      kind: "tool",
-      canonicalOwnerScope: "platform",
-      editSurface: "platform_admin",
-      inheritanceRule: "platform_seed_to_tenant",
-      blastRadius: "platform"
-    },
-    {
-      caseKey: "tenant-custom",
-      caseLabel: "Tenant Custom",
-      kind: "tool",
-      canonicalOwnerScope: "tenant",
-      editSurface: "tenant_admin",
-      inheritanceRule: "tenant_default_to_workspace",
-      blastRadius: "tenant"
-    }
-  ]),
-  pack: defineCases([
-    {
-      caseKey: "platform-definition",
-      caseLabel: "Platform Definition",
-      kind: "pack",
-      canonicalOwnerScope: "platform",
-      editSurface: "platform_admin",
-      inheritanceRule: "platform_seed_to_tenant",
-      blastRadius: "platform"
-    },
-    {
-      caseKey: "tenant-installation",
-      caseLabel: "Tenant Installation",
-      kind: "pack",
-      canonicalOwnerScope: "tenant",
-      editSurface: "tenant_admin",
-      inheritanceRule: "platform_seed_to_tenant",
-      blastRadius: "tenant"
-    }
-  ]),
-  ontology: defineCases([
-    {
-      caseKey: "platform-base",
-      caseLabel: "Platform Base",
-      kind: "ontology",
-      canonicalOwnerScope: "platform",
-      editSurface: "platform_admin",
-      inheritanceRule: "platform_seed_to_tenant",
-      blastRadius: "platform"
-    },
-    {
-      caseKey: "pack-overlay",
-      caseLabel: "Pack Overlay",
-      kind: "ontology",
-      canonicalOwnerScope: "platform",
-      editSurface: "platform_admin",
-      inheritanceRule: "pack_overlay_to_tenant",
-      blastRadius: "platform"
-    },
-    {
-      caseKey: "tenant-extension",
-      caseLabel: "Tenant Extension",
-      kind: "ontology",
-      canonicalOwnerScope: "tenant",
-      editSurface: "tenant_admin",
-      inheritanceRule: "topic_lineage_to_resource",
-      blastRadius: "tenant"
-    }
-  ]),
-  belief: defineCases([
-    {
-      caseKey: "topic-resource",
-      caseLabel: "Topic Resource",
-      kind: "belief",
-      canonicalOwnerScope: "resource",
-      editSurface: "graph_worktree",
-      inheritanceRule: "topic_lineage_to_resource",
-      blastRadius: "resource"
-    }
-  ]),
-  policy_rule: defineCases([
-    {
-      caseKey: "platform-baseline",
-      caseLabel: "Platform Baseline",
-      kind: "policy_rule",
-      canonicalOwnerScope: "platform",
-      editSurface: "platform_admin",
-      inheritanceRule: "platform_seed_to_tenant",
-      blastRadius: "platform"
-    },
-    {
-      caseKey: "tenant-bundle",
-      caseLabel: "Tenant Bundle",
-      kind: "policy_rule",
-      canonicalOwnerScope: "tenant",
-      editSurface: "tenant_admin",
-      inheritanceRule: "tenant_default_to_workspace",
-      blastRadius: "tenant"
-    },
-    {
-      caseKey: "workspace-override",
-      caseLabel: "Workspace Override",
-      kind: "policy_rule",
-      canonicalOwnerScope: "workspace",
-      editSurface: "workspace_admin",
-      inheritanceRule: "none",
-      blastRadius: "workspace"
-    }
-  ])
-};
-function flattenOwnershipMatrix(matrix) {
-  return CONTROL_OBJECT_KINDS.flatMap((kind) => [...matrix[kind]]);
+function cleanNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-Object.freeze(
-  flattenOwnershipMatrix(CONTROL_OBJECT_OWNERSHIP_MATRIX)
-);
-globalThis.process?.env;
-
-// src/types.ts
-var McpHandlerError = class extends Error {
-  code;
-  status;
-  suggestion;
-  constructor(message, code = "INVALID_REQUEST", status = 400, suggestion) {
-    super(message);
-    this.name = "McpHandlerError";
-    this.code = code;
-    this.status = status;
-    this.suggestion = suggestion;
+function cleanBoolean2(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function buildCompileContextRequest2(topicId, input = {}) {
+  const payload = { topicId };
+  const query5 = cleanString6(input.query);
+  if (query5) {
+    payload.query = query5;
   }
-};
-
-// src/handler-factory.ts
-function isMissing(value) {
-  if (value === void 0 || value === null) {
-    return true;
+  const budget = cleanNumber2(input.budget) ?? cleanNumber2(input.tokenBudget);
+  if (budget !== void 0) {
+    payload.budget = budget;
   }
-  if (typeof value === "string") {
-    return value.trim().length === 0;
+  const ranking = cleanString6(input.ranking) ?? cleanString6(input.rankingProfile);
+  if (ranking) {
+    payload.ranking = ranking;
   }
-  if (Array.isArray(value)) {
-    return value.length === 0;
+  const limit = cleanNumber2(input.limit);
+  if (limit !== void 0) {
+    payload.limit = limit;
   }
-  return false;
+  const maxDepth = cleanNumber2(input.maxDepth);
+  if (maxDepth !== void 0) {
+    payload.maxDepth = maxDepth;
+  }
+  const includeEntities = cleanBoolean2(input.includeEntities);
+  if (includeEntities !== void 0) {
+    payload.includeEntities = includeEntities;
+  }
+  const mode = cleanString6(input.mode);
+  if (mode) {
+    payload.mode = mode;
+  }
+  const includeFailures = cleanBoolean2(input.includeFailures);
+  if (includeFailures !== void 0) {
+    payload.includeFailures = includeFailures;
+  }
+  const worktreeId = cleanString6(input.worktreeId);
+  if (worktreeId) {
+    payload.worktreeId = worktreeId;
+  }
+  const sessionId = cleanString6(input.sessionId);
+  if (sessionId) {
+    payload.sessionId = sessionId;
+  }
+  if (Array.isArray(input.packWeightOverrides) && input.packWeightOverrides.length > 0) {
+    payload.packWeightOverrides = input.packWeightOverrides;
+  }
+  return {
+    path: "/api/platform/v1/context/compile",
+    method: "POST",
+    body: payload
+  };
+}
+function createContextFacade(config) {
+  return {
+    compile(topicId, input = {}) {
+      const request = buildCompileContextRequest2(topicId, input);
+      return config.transport.request(request);
+    }
+  };
+}
+
+// ../sdk/src/contracts/context-pack.contract.ts
+var CONTEXT_PACK_SCHEMA_VERSION = "1.0.0";
+var DEFAULT_COMPILATION_MODE = "standard";
+var SECTION_BUDGET_RATIOS = {
+  invariants: 0.28,
+  activeBeliefs: 0.3,
+  openQuestions: 0.17,
+  recentEvidence: 0.17,
+  contradictions: 0.08
+};
+var MIN_TOKEN_BUDGET = 400;
+var MAX_TOKEN_BUDGET = 8e3;
+var DEFAULT_TOKEN_BUDGET = 1800;
+var MIN_CONTRADICTION_BUDGET = 40;
+var RANKING_WEIGHTS = {
+  invariants: {
+    query: 0.35,
+    recency: 0.1,
+    confidence: 0.4,
+    beliefType: 0.15
+  },
+  activeBeliefs: {
+    query: 0.5,
+    recency: 0.2,
+    confidence: 0.2,
+    beliefType: 0.1
+  },
+  openQuestions: {
+    query: 0.55,
+    recency: 0.2,
+    priority: 0.25
+  },
+  recentEvidence: {
+    query: 0.6,
+    recency: 0.4
+  },
+  contradictions: {
+    query: 0.4,
+    recency: 0.2,
+    severity: 0.4
+  }
+};
+var RECENCY_HALF_LIFE_DAYS = 30;
+var ENTITY_RANKING_WEIGHTS = {
+  query: 0.4,
+  connectivity: 0.6
+};
+var DEFAULT_ENTITY_LIMIT = 10;
+var MAX_ENTITY_LIMIT = 50;
+var BELIEF_TYPE_BONUS = {
+  invariant: 1,
+  tenet: 0.8,
+  principle: 0.6
+};
+var DEFAULT_BELIEF_TYPE_BONUS = 0.4;
+var PRIORITY_SCORES = {
+  critical: 1,
+  high: 0.85,
+  medium: 0.55,
+  low: 0.35
+};
+var DEFAULT_PRIORITY_SCORE = 0.5;
+var SEVERITY_SCORES = {
+  critical: 1,
+  high: 0.85,
+  medium: 0.6,
+  low: 0.35
+};
+var DEFAULT_SEVERITY_SCORE = 0.5;
+var TOKENS_PER_WORD = 1.35;
+var MIN_TOKEN_ESTIMATE = 8;
+
+// ../sdk/src/contextPackPolicy.ts
+function nowMs() {
+  return Date.now();
+}
+function normalizeText(text) {
+  return text.trim().toLowerCase();
+}
+function tokenHits(text, tokens) {
+  if (tokens.length === 0) {
+    return 1;
+  }
+  const haystack = normalizeText(text);
+  let hits = 0;
+  for (const token of tokens) {
+    if (haystack.includes(token)) {
+      hits += 1;
+    }
+  }
+  return hits;
+}
+function clamp013(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(1, value));
+}
+function recencyScore(updatedAt, referenceTimeMs = nowMs()) {
+  if (!updatedAt || !Number.isFinite(updatedAt)) {
+    return 0.25;
+  }
+  const ageMs = Math.max(0, referenceTimeMs - updatedAt);
+  const ageDays = ageMs / (1e3 * 60 * 60 * 24);
+  const decay = 0.5 ** (ageDays / RECENCY_HALF_LIFE_DAYS);
+  return clamp013(decay);
+}
+function confidenceScore(confidence) {
+  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
+    return 0.5;
+  }
+  return clamp013(confidence);
+}
+function priorityScore(priority) {
+  const value = normalizeText(priority || "");
+  return PRIORITY_SCORES[value] ?? DEFAULT_PRIORITY_SCORE;
+}
+function severityScore(severity) {
+  const value = normalizeText(severity || "");
+  return SEVERITY_SCORES[value] ?? DEFAULT_SEVERITY_SCORE;
+}
+function beliefTypeBonus(beliefType) {
+  const value = normalizeText(beliefType || "");
+  return BELIEF_TYPE_BONUS[value] ?? DEFAULT_BELIEF_TYPE_BONUS;
+}
+function resolveEffectiveWeights(overrides) {
+  if (!overrides || overrides.length === 0) {
+    return RANKING_WEIGHTS;
+  }
+  const result = { ...RANKING_WEIGHTS };
+  for (const override of overrides) {
+    const base = RANKING_WEIGHTS[override.section];
+    if (base) {
+      result[override.section] = { ...base, ...override.weights };
+    }
+  }
+  return result;
+}
+function generateJustification(_section, candidate, queryTokens, weights) {
+  const parts = [];
+  const hits = tokenHits(candidate.text, queryTokens);
+  if (queryTokens.length > 0 && hits > 0) {
+    parts.push(`${hits}/${queryTokens.length} query terms matched`);
+  } else if (queryTokens.length === 0) {
+    parts.push("no query filter");
+  }
+  const ts = candidate.updatedAt || candidate.createdAt || null;
+  if (ts && Number.isFinite(ts)) {
+    const ageDays = Math.max(0, nowMs() - ts) / (1e3 * 60 * 60 * 24);
+    if (ageDays < 1) {
+      parts.push("updated today");
+    } else if (ageDays < 7) {
+      parts.push(`updated ${Math.floor(ageDays)}d ago`);
+    } else if (ageDays < 30) {
+      parts.push(`updated ${Math.floor(ageDays / 7)}w ago`);
+    } else {
+      parts.push(`updated ${Math.floor(ageDays)}d ago (decayed)`);
+    }
+  }
+  if (weights.confidence !== void 0 && candidate.confidence !== null && candidate.confidence !== void 0) {
+    parts.push(`confidence=${candidate.confidence.toFixed(2)}`);
+  }
+  if (weights.beliefType !== void 0 && candidate.beliefType) {
+    parts.push(`type=${candidate.beliefType}`);
+  }
+  if (weights.priority !== void 0 && candidate.priority) {
+    parts.push(`priority=${candidate.priority}`);
+  }
+  if (weights.severity !== void 0 && candidate.severity) {
+    parts.push(`severity=${candidate.severity}`);
+  }
+  return parts.join(", ");
+}
+function computeBaselineScore(candidate, queryTokens) {
+  const hits = tokenHits(candidate.text, queryTokens);
+  return queryTokens.length === 0 ? 1 : hits;
+}
+function computeWeightedScore(section, candidate, queryTokens, effectiveWeights, referenceTimeMs) {
+  const weights = (effectiveWeights ?? RANKING_WEIGHTS)[section];
+  const queryComponent = queryTokens.length === 0 ? 0.4 : clamp013(tokenHits(candidate.text, queryTokens) / queryTokens.length);
+  const recencyComponent = recencyScore(
+    candidate.updatedAt || candidate.createdAt || null,
+    referenceTimeMs
+  );
+  let score = queryComponent * weights.query + recencyComponent * weights.recency;
+  if (weights.confidence !== void 0) {
+    score += confidenceScore(candidate.confidence) * weights.confidence;
+  }
+  if (weights.beliefType !== void 0) {
+    score += beliefTypeBonus(candidate.beliefType) * weights.beliefType;
+  }
+  if (weights.priority !== void 0) {
+    score += priorityScore(candidate.priority) * weights.priority;
+  }
+  if (weights.severity !== void 0) {
+    score += severityScore(candidate.severity) * weights.severity;
+  }
+  return score;
+}
+function rankContextSection(section, rows, queryTokens, limit, profile, options) {
+  const effectiveWeights = options?.effectiveWeights;
+  const includeJustifications = options?.includeJustifications ?? false;
+  const referenceTimeMs = options?.referenceTimeMs;
+  const scored = rows.map((row) => {
+    const score = profile === "weighted_v1" ? computeWeightedScore(
+      section,
+      row,
+      queryTokens,
+      effectiveWeights,
+      referenceTimeMs
+    ) : computeBaselineScore(row, queryTokens);
+    const result = { ...row, score };
+    if (includeJustifications && profile === "weighted_v1") {
+      const weights = (effectiveWeights ?? RANKING_WEIGHTS)[section];
+      result.justification = generateJustification(section, row, queryTokens, weights);
+    }
+    return result;
+  });
+  const filtered = queryTokens.length === 0 ? scored : scored.filter((row) => row.score > 0);
+  filtered.sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    const rightTs = right.updatedAt || right.createdAt || 0;
+    const leftTs = left.updatedAt || left.createdAt || 0;
+    return rightTs - leftTs;
+  });
+  return filtered.slice(0, limit);
+}
+function parseTokenBudget(value, fallback = DEFAULT_TOKEN_BUDGET) {
+  const parsed = typeof value === "number" && Number.isFinite(value) ? Math.floor(value) : fallback;
+  return Math.max(MIN_TOKEN_BUDGET, Math.min(MAX_TOKEN_BUDGET, parsed));
+}
+function estimateTokens(text) {
+  const words = text.trim().split(/\s+/).filter(Boolean).length;
+  return Math.max(MIN_TOKEN_ESTIMATE, Math.ceil(words * TOKENS_PER_WORD));
+}
+function buildInjectionPlan(args) {
+  const tokenBudget = parseTokenBudget(args.tokenBudget);
+  const trackExclusions = args.trackExclusions ?? false;
+  const sectionBudgets = {
+    invariants: Math.floor(tokenBudget * SECTION_BUDGET_RATIOS.invariants),
+    activeBeliefs: Math.floor(
+      tokenBudget * SECTION_BUDGET_RATIOS.activeBeliefs
+    ),
+    openQuestions: Math.floor(
+      tokenBudget * SECTION_BUDGET_RATIOS.openQuestions
+    ),
+    recentEvidence: Math.floor(
+      tokenBudget * SECTION_BUDGET_RATIOS.recentEvidence
+    ),
+    contradictions: Math.max(
+      MIN_CONTRADICTION_BUDGET,
+      Math.floor(tokenBudget * SECTION_BUDGET_RATIOS.contradictions)
+    )
+  };
+  const selected = {
+    invariants: [],
+    activeBeliefs: [],
+    openQuestions: [],
+    recentEvidence: [],
+    contradictions: []
+  };
+  const sectionUsage = {
+    invariants: 0,
+    activeBeliefs: 0,
+    openQuestions: 0,
+    recentEvidence: 0,
+    contradictions: 0
+  };
+  const excludedItems = [];
+  const pushItem = (section, id, text, score) => {
+    const itemTokens = estimateTokens(text);
+    const nextUsage = sectionUsage[section] + itemTokens;
+    if (nextUsage > sectionBudgets[section]) {
+      if (trackExclusions) {
+        excludedItems.push({
+          id,
+          section,
+          reason: "budget_exceeded",
+          score: score ?? 0
+        });
+      }
+      return;
+    }
+    selected[section].push(id);
+    sectionUsage[section] = nextUsage;
+  };
+  for (const row of args.invariants) {
+    pushItem("invariants", row.nodeId, row.canonicalText, row.score);
+  }
+  for (const row of args.activeBeliefs) {
+    pushItem("activeBeliefs", row.nodeId, row.canonicalText, row.score);
+  }
+  for (const row of args.openQuestions) {
+    pushItem("openQuestions", row.questionId, row.text, row.score);
+  }
+  for (const row of args.recentEvidence) {
+    pushItem("recentEvidence", row.nodeId, row.canonicalText, row.score);
+  }
+  for (const row of args.contradictions) {
+    pushItem("contradictions", row.contradictionId, row.description, row.score);
+  }
+  const estimatedTokens = sectionUsage.invariants + sectionUsage.activeBeliefs + sectionUsage.openQuestions + sectionUsage.recentEvidence + sectionUsage.contradictions;
+  return {
+    tokenBudget,
+    estimatedTokens,
+    sectionBudgets,
+    sectionUsage,
+    selected,
+    ...trackExclusions ? { excludedItems } : {}
+  };
+}
+function rankEntities(candidates, queryTokens, limit) {
+  if (candidates.length === 0) {
+    return [];
+  }
+  const effectiveLimit = Math.max(
+    1,
+    Math.min(limit ?? DEFAULT_ENTITY_LIMIT, MAX_ENTITY_LIMIT)
+  );
+  const maxConnections = Math.max(
+    1,
+    ...candidates.map(
+      (candidate) => candidate.connectedBeliefCount + candidate.connectedEvidenceCount
+    )
+  );
+  const scored = candidates.map((candidate) => {
+    const searchText = `${candidate.title} ${candidate.entityType} ${candidate.canonicalText}`;
+    const queryScore = queryTokens.length === 0 ? 0.4 : clamp013(tokenHits(searchText, queryTokens) / queryTokens.length);
+    const totalConnections = candidate.connectedBeliefCount + candidate.connectedEvidenceCount;
+    const connectivityScore = clamp013(totalConnections / maxConnections);
+    const score = queryScore * ENTITY_RANKING_WEIGHTS.query + connectivityScore * ENTITY_RANKING_WEIGHTS.connectivity;
+    return { ...candidate, score };
+  });
+  scored.sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    const rightConn = right.connectedBeliefCount + right.connectedEvidenceCount;
+    const leftConn = left.connectedBeliefCount + left.connectedEvidenceCount;
+    return rightConn - leftConn;
+  });
+  return scored.slice(0, effectiveLimit);
+}
+
+// ../sdk/src/contextPackSchema.ts
+var CONTEXT_PACK_SCHEMA_VERSION2 = "1.0.0";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isNullableNumber(value) {
+  return value === null || isNumber(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => isString(entry));
+}
+function requireObject(parent, key, errors) {
+  const value = parent[key];
+  if (!isObject(value)) {
+    errors.push(`Expected '${key}' to be an object`);
+    return null;
+  }
+  return value;
+}
+function validateBeliefArray(key, value, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`Expected '${key}' to be an array`);
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const row = value[index];
+    if (!isObject(row)) {
+      errors.push(`Expected '${key}[${index}]' to be an object`);
+      continue;
+    }
+    if (!isString(row.nodeId)) {
+      errors.push(`Expected '${key}[${index}].nodeId' to be a string`);
+    }
+    if (!isString(row.canonicalText)) {
+      errors.push(`Expected '${key}[${index}].canonicalText' to be a string`);
+    }
+    if (!isNullableNumber(row.confidence)) {
+      errors.push(`Expected '${key}[${index}].confidence' to be number|null`);
+    }
+  }
+}
+function validateQuestionArray(key, value, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`Expected '${key}' to be an array`);
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const row = value[index];
+    if (!isObject(row)) {
+      errors.push(`Expected '${key}[${index}]' to be an object`);
+      continue;
+    }
+    if (!isString(row.questionId)) {
+      errors.push(`Expected '${key}[${index}].questionId' to be a string`);
+    }
+    if (!isString(row.text)) {
+      errors.push(`Expected '${key}[${index}].text' to be a string`);
+    }
+    if (!isString(row.status)) {
+      errors.push(`Expected '${key}[${index}].status' to be a string`);
+    }
+  }
+}
+function validateEvidenceArray(key, value, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`Expected '${key}' to be an array`);
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const row = value[index];
+    if (!isObject(row)) {
+      errors.push(`Expected '${key}[${index}]' to be an object`);
+      continue;
+    }
+    if (!isString(row.nodeId)) {
+      errors.push(`Expected '${key}[${index}].nodeId' to be a string`);
+    }
+    if (!isString(row.canonicalText)) {
+      errors.push(`Expected '${key}[${index}].canonicalText' to be a string`);
+    }
+  }
+}
+function validateEntityArray(key, value, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`Expected '${key}' to be an array`);
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const row = value[index];
+    if (!isObject(row)) {
+      errors.push(`Expected '${key}[${index}]' to be an object`);
+      continue;
+    }
+    if (!isString(row.nodeId)) {
+      errors.push(`Expected '${key}[${index}].nodeId' to be a string`);
+    }
+    if (!isString(row.entityType)) {
+      errors.push(`Expected '${key}[${index}].entityType' to be a string`);
+    }
+    if (!isString(row.title)) {
+      errors.push(`Expected '${key}[${index}].title' to be a string`);
+    }
+    if (!isNumber(row.connectedBeliefCount)) {
+      errors.push(`Expected '${key}[${index}].connectedBeliefCount' to be a number`);
+    }
+    if (!isNumber(row.connectedEvidenceCount)) {
+      errors.push(`Expected '${key}[${index}].connectedEvidenceCount' to be a number`);
+    }
+    if (!isNumber(row.score)) {
+      errors.push(`Expected '${key}[${index}].score' to be a number`);
+    }
+  }
+}
+function validateContradictionArray(key, value, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`Expected '${key}' to be an array`);
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const row = value[index];
+    if (!isObject(row)) {
+      errors.push(`Expected '${key}[${index}]' to be an object`);
+      continue;
+    }
+    if (!isString(row.contradictionId)) {
+      errors.push(`Expected '${key}[${index}].contradictionId' to be a string`);
+    }
+    if (!isString(row.status)) {
+      errors.push(`Expected '${key}[${index}].status' to be a string`);
+    }
+  }
+}
+function validateContextPackSchema(payload) {
+  const errors = [];
+  if (!isObject(payload)) {
+    return {
+      valid: false,
+      errors: ["Expected context pack payload to be an object"]
+    };
+  }
+  if (payload.schemaVersion !== CONTEXT_PACK_SCHEMA_VERSION2) {
+    errors.push(
+      `Expected schemaVersion='${CONTEXT_PACK_SCHEMA_VERSION2}', received '${String(
+        payload.schemaVersion
+      )}'`
+    );
+  }
+  if (!isString(payload.topicId)) {
+    errors.push("Expected 'topicId' to be a string");
+  }
+  if (!isString(payload.topicName)) {
+    errors.push("Expected 'topicName' to be a string");
+  }
+  if (!isStringArray(payload.scopedTopicIds)) {
+    errors.push("Expected 'scopedTopicIds' to be string[]");
+  }
+  if (!isNumber(payload.generatedAt)) {
+    errors.push("Expected 'generatedAt' to be a number");
+  }
+  if (!isString(payload.ranking)) {
+    errors.push("Expected 'ranking' to be a string");
+  }
+  validateBeliefArray("invariants", payload.invariants, errors);
+  validateBeliefArray("activeBeliefs", payload.activeBeliefs, errors);
+  validateQuestionArray("openQuestions", payload.openQuestions, errors);
+  validateEvidenceArray("recentEvidence", payload.recentEvidence, errors);
+  validateContradictionArray("contradictions", payload.contradictions, errors);
+  if (payload.relatedEntities !== void 0 && payload.relatedEntities !== null) {
+    validateEntityArray("relatedEntities", payload.relatedEntities, errors);
+  }
+  if (!Array.isArray(payload.contextNarrative)) {
+    errors.push("Expected 'contextNarrative' to be an array");
+  }
+  const injectionPolicy = requireObject(payload, "injectionPolicy", errors);
+  if (injectionPolicy) {
+    if (!isNumber(injectionPolicy.tokenBudget)) {
+      errors.push("Expected 'injectionPolicy.tokenBudget' to be a number");
+    }
+    if (!isNumber(injectionPolicy.estimatedTokens)) {
+      errors.push("Expected 'injectionPolicy.estimatedTokens' to be a number");
+    }
+  }
+  if (!isObject(payload.summary)) {
+    errors.push("Expected 'summary' to be an object");
+  }
+  if (!isObject(payload.diagnostics)) {
+    errors.push("Expected 'diagnostics' to be an object");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// ../sdk/src/contextPackCompiler.ts
+function assertContextPackSchema(payload) {
+  const result = validateContextPackSchema(payload);
+  if (!result.valid) {
+    throw new Error(
+      `Invalid context pack payload: ${result.errors.join("; ")}`
+    );
+  }
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0);
+}
+function toPositiveInt(value, fallback, max) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  const floored = Math.floor(value);
+  return Math.max(1, Math.min(floored, max));
+}
+function normalizeQueryTokens(query5) {
+  if (!query5) {
+    return [];
+  }
+  return query5.toLowerCase().split(/[^a-z0-9]+/).map((token) => token.trim()).filter((token) => token.length >= 2);
+}
+function parseRankingProfile(value) {
+  return value === "baseline_v1" ? "baseline_v1" : "weighted_v1";
+}
+function beliefTypeOf(node) {
+  if (typeof node.beliefType === "string") {
+    return node.beliefType;
+  }
+  const metadata = node.metadata || {};
+  if (typeof metadata.beliefType === "string") {
+    return metadata.beliefType;
+  }
+  return "";
+}
+function questionStatusOf(node) {
+  const metadata = node.metadata || {};
+  const direct = typeof node.status === "string" ? node.status : "";
+  const questionStatus = typeof metadata.questionStatus === "string" ? metadata.questionStatus : "";
+  return (questionStatus || direct || "open").toLowerCase();
+}
+function isOpenQuestion(status) {
+  return ![
+    "answered",
+    "archived",
+    "closed",
+    "resolved",
+    "resolved_support",
+    "resolved_contra",
+    "belief_forked"
+  ].includes(status);
+}
+function metadataText(payload) {
+  return JSON.stringify(payload).toLowerCase();
+}
+function collectTopicNeighborhood(topics2, rootTopicId, maxDescendantDepth = 2) {
+  const byId = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const topic of topics2) {
+    const id = String(topic._id);
+    byId.set(id, topic);
+    if (!children.has(id)) {
+      children.set(id, []);
+    }
+  }
+  for (const topic of topics2) {
+    if (!topic.parentTopicId) {
+      continue;
+    }
+    const parent = String(topic.parentTopicId);
+    const id = String(topic._id);
+    const list = children.get(parent) || [];
+    list.push(id);
+    children.set(parent, list);
+  }
+  const selected = /* @__PURE__ */ new Set([rootTopicId]);
+  let cursor = byId.get(rootTopicId);
+  while (cursor?.parentTopicId) {
+    const parentId = String(cursor.parentTopicId);
+    if (selected.has(parentId)) {
+      break;
+    }
+    selected.add(parentId);
+    cursor = byId.get(parentId);
+  }
+  const queue = [
+    { id: rootTopicId, depth: 0 }
+  ];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || current.depth >= maxDescendantDepth) {
+      continue;
+    }
+    for (const childId of children.get(current.id) || []) {
+      if (!selected.has(childId)) {
+        selected.add(childId);
+      }
+      queue.push({ id: childId, depth: current.depth + 1 });
+    }
+  }
+  return Array.from(selected);
+}
+function dedupeById(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const output = [];
+  for (const row of rows) {
+    const id = row?._id ? String(row._id) : "";
+    if (!id || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    output.push(row);
+  }
+  return output;
+}
+function candidateTimestamp(candidate) {
+  if (!candidate || typeof candidate !== "object") {
+    return 0;
+  }
+  const record = candidate;
+  const timestamps = [record.updatedAt, record.createdAt, record.generatedAt].filter(
+    (value) => typeof value === "number" && Number.isFinite(value)
+  );
+  return timestamps.length > 0 ? Math.max(...timestamps) : 0;
+}
+function resolveReferenceTimeMs(...collections) {
+  let maxTimestamp = 0;
+  for (const collection of collections) {
+    for (const item of collection) {
+      const timestamp = candidateTimestamp(item);
+      if (timestamp > maxTimestamp) {
+        maxTimestamp = timestamp;
+      }
+    }
+  }
+  return maxTimestamp;
+}
+function planContextPackCompilation(input) {
+  const args = input.args ?? {};
+  const topicId = String(input.topic._id);
+  const queryText = typeof args.query === "string" && args.query.trim().length > 0 ? args.query.trim() : void 0;
+  const tokens = normalizeQueryTokens(queryText);
+  const limit = toPositiveInt(args.limit, 8, 25);
+  const rankingProfile = parseRankingProfile(
+    typeof args.ranking === "string" ? args.ranking : args.rankingProfile
+  );
+  const tokenBudget = parseTokenBudget(
+    typeof args.budget === "number" ? args.budget : args.tokenBudget,
+    1800
+  );
+  const topicDepth = typeof input.topic.depth === "number" && Number.isFinite(input.topic.depth) ? input.topic.depth : 0;
+  const requestedMaxDepth = typeof args.maxDepth === "number" && Number.isFinite(args.maxDepth) ? Math.max(1, Math.min(Math.floor(args.maxDepth), 6)) : void 0;
+  const descendantDepth = requestedMaxDepth ?? (topicDepth <= 1 ? 4 : 2);
+  const includeEntities = args.includeEntities !== false;
+  const compilationMode = args.mode === "delta" ? "delta" : DEFAULT_COMPILATION_MODE;
+  const includeFailures = compilationMode === "delta" || args.includeFailures === true;
+  const worktreeId = typeof args.worktreeId === "string" && args.worktreeId.trim().length > 0 ? args.worktreeId.trim() : void 0;
+  const sessionId = typeof args.sessionId === "string" && args.sessionId.trim().length > 0 ? args.sessionId.trim() : void 0;
+  const packWeightOverrides = Array.isArray(args.packWeightOverrides) ? args.packWeightOverrides : void 0;
+  const effectiveWeights = resolveEffectiveWeights(packWeightOverrides);
+  let scopedTopicIds = collectTopicNeighborhood(
+    input.allTopics,
+    topicId,
+    descendantDepth
+  );
+  const allowedTopicIds = asStringArray(args.allowedTopicIds);
+  if (allowedTopicIds.length > 0) {
+    const allowedSet = new Set(allowedTopicIds);
+    if (!allowedSet.has(topicId)) {
+      throw new Error(`Access denied to compile context for topic ${topicId}.`);
+    }
+    scopedTopicIds = scopedTopicIds.filter((id) => allowedSet.has(id));
+  }
+  return {
+    topicId,
+    ...queryText ? { queryText } : {},
+    tokens,
+    limit,
+    rankingProfile,
+    tokenBudget,
+    descendantDepth,
+    includeEntities,
+    compilationMode,
+    includeFailures,
+    ...worktreeId ? { worktreeId } : {},
+    ...sessionId ? { sessionId } : {},
+    ...packWeightOverrides ? { packWeightOverrides } : {},
+    effectiveWeights,
+    scopedTopicIds
+  };
+}
+function compileContextPackFromSnapshot(snapshot) {
+  const uniqueBeliefs = dedupeById(snapshot.beliefs);
+  const uniqueQuestions = dedupeById(snapshot.questions);
+  const uniqueEvidence = dedupeById(snapshot.evidence);
+  const uniqueContradictions = dedupeById(snapshot.contradictions);
+  const referenceTimeMs = resolveReferenceTimeMs(
+    [snapshot.topic],
+    uniqueBeliefs,
+    uniqueQuestions,
+    uniqueEvidence,
+    uniqueContradictions,
+    snapshot.entities
+  ) || 0;
+  const rankOptions = {
+    effectiveWeights: snapshot.plan.effectiveWeights,
+    includeJustifications: snapshot.plan.compilationMode === "delta",
+    referenceTimeMs
+  };
+  const invariantCandidates = uniqueBeliefs.filter((belief) => beliefTypeOf(belief).toLowerCase() === "invariant").map((belief) => ({
+    nodeId: String(belief._id),
+    canonicalText: String(belief.canonicalText || ""),
+    confidence: typeof belief.confidence === "number" ? belief.confidence : null,
+    beliefType: beliefTypeOf(belief) || "invariant",
+    updatedAt: belief.updatedAt || belief.createdAt || null
+  }));
+  const invariants = rankContextSection(
+    "invariants",
+    invariantCandidates.map((candidate) => ({
+      ...candidate,
+      id: candidate.nodeId,
+      text: `${candidate.canonicalText} ${candidate.beliefType}`
+    })),
+    snapshot.plan.tokens,
+    snapshot.plan.limit,
+    snapshot.plan.rankingProfile,
+    rankOptions
+  ).map((row) => ({
+    nodeId: row.nodeId,
+    canonicalText: row.canonicalText,
+    confidence: row.confidence,
+    beliefType: row.beliefType,
+    score: row.score,
+    ...row.justification ? { justification: row.justification } : {}
+  }));
+  const activeBeliefCandidates = uniqueBeliefs.filter((belief) => (belief.status || "active") !== "archived").map((belief) => ({
+    nodeId: String(belief._id),
+    canonicalText: String(belief.canonicalText || ""),
+    confidence: typeof belief.confidence === "number" ? belief.confidence : null,
+    beliefType: beliefTypeOf(belief) || null,
+    status: belief.status || "active",
+    updatedAt: belief.updatedAt || belief.createdAt || null,
+    metadataText: belief.metadata && typeof belief.metadata === "object" ? metadataText(belief.metadata) : ""
+  }));
+  const activeBeliefs = rankContextSection(
+    "activeBeliefs",
+    activeBeliefCandidates.map((candidate) => ({
+      ...candidate,
+      id: candidate.nodeId,
+      text: `${candidate.canonicalText} ${candidate.metadataText}`
+    })),
+    snapshot.plan.tokens,
+    snapshot.plan.limit,
+    snapshot.plan.rankingProfile,
+    rankOptions
+  ).map((row) => ({
+    nodeId: row.nodeId,
+    canonicalText: row.canonicalText,
+    confidence: row.confidence,
+    beliefType: row.beliefType,
+    status: row.status,
+    updatedAt: row.updatedAt,
+    score: row.score,
+    ...row.justification ? { justification: row.justification } : {}
+  }));
+  const openQuestionCandidates = uniqueQuestions.map((question) => {
+    const status = questionStatusOf(question);
+    const metadata = question.metadata && typeof question.metadata === "object" ? question.metadata : {};
+    return {
+      questionId: String(question._id),
+      text: String(question.canonicalText || ""),
+      status,
+      priority: typeof metadata.priority === "string" ? metadata.priority : "medium",
+      updatedAt: question.updatedAt || question.createdAt || null,
+      metadataText: metadataText(metadata)
+    };
+  }).filter((row) => isOpenQuestion(row.status));
+  const openQuestions = rankContextSection(
+    "openQuestions",
+    openQuestionCandidates.map((candidate) => ({
+      ...candidate,
+      id: candidate.questionId,
+      text: `${candidate.text} ${candidate.metadataText}`
+    })),
+    snapshot.plan.tokens,
+    snapshot.plan.limit,
+    snapshot.plan.rankingProfile,
+    rankOptions
+  ).map((row) => ({
+    questionId: row.questionId,
+    text: row.text,
+    status: row.status,
+    priority: row.priority,
+    updatedAt: row.updatedAt,
+    score: row.score,
+    ...row.justification ? { justification: row.justification } : {}
+  }));
+  const evidenceCandidates = uniqueEvidence.map((item) => {
+    const metadata = item.metadata && typeof item.metadata === "object" ? item.metadata : {};
+    return {
+      nodeId: String(item._id),
+      canonicalText: String(item.canonicalText || ""),
+      sourceUrl: typeof metadata.sourceUrl === "string" && metadata.sourceUrl || typeof item.sourceUrl === "string" && item.sourceUrl || null,
+      kind: typeof metadata.kind === "string" && metadata.kind || "observation",
+      createdAt: item.createdAt || null,
+      updatedAt: item.updatedAt || item.createdAt || null,
+      metadataText: metadataText(metadata)
+    };
+  });
+  const recentEvidence = rankContextSection(
+    "recentEvidence",
+    evidenceCandidates.map((candidate) => ({
+      ...candidate,
+      id: candidate.nodeId,
+      text: `${candidate.canonicalText} ${candidate.metadataText}`
+    })),
+    snapshot.plan.tokens,
+    snapshot.plan.limit,
+    snapshot.plan.rankingProfile,
+    rankOptions
+  ).map((row) => ({
+    nodeId: row.nodeId,
+    canonicalText: row.canonicalText,
+    sourceUrl: row.sourceUrl,
+    kind: row.kind,
+    createdAt: row.createdAt,
+    score: row.score,
+    ...row.justification ? { justification: row.justification } : {}
+  }));
+  const contradictionCandidates = uniqueContradictions.map((row) => {
+    const weight = typeof row.weight === "number" ? row.weight : 0;
+    const severity = weight <= -0.9 ? "critical" : weight <= -0.7 ? "high" : weight <= -0.5 ? "medium" : "low";
+    return {
+      contradictionId: String(row._id || row.globalId || ""),
+      severity,
+      status: "active",
+      description: row.context || row.description || row.summary || "",
+      updatedAt: row.updatedAt || row.createdAt || null
+    };
+  });
+  const contradictions2 = rankContextSection(
+    "contradictions",
+    contradictionCandidates.map((candidate) => ({
+      ...candidate,
+      id: candidate.contradictionId,
+      text: `${candidate.description} ${candidate.severity}`
+    })),
+    snapshot.plan.tokens,
+    snapshot.plan.limit,
+    snapshot.plan.rankingProfile,
+    rankOptions
+  ).map((row) => ({
+    contradictionId: row.contradictionId,
+    severity: row.severity,
+    status: row.status,
+    description: row.description,
+    score: row.score,
+    ...row.justification ? { justification: row.justification } : {}
+  }));
+  const entityCandidates = snapshot.entities.map((row) => ({
+    nodeId: String(row._id),
+    entityType: String(row.nodeType || ""),
+    title: String(row.title || ""),
+    canonicalText: String(row.canonicalText || ""),
+    connectedBeliefCount: typeof row.connectedBeliefCount === "number" ? row.connectedBeliefCount : 0,
+    connectedEvidenceCount: typeof row.connectedEvidenceCount === "number" ? row.connectedEvidenceCount : 0,
+    metadata: row.metadata && typeof row.metadata === "object" ? row.metadata : {},
+    updatedAt: row.updatedAt || null
+  }));
+  const entityLimit = toPositiveInt(
+    snapshot.plan.limit,
+    DEFAULT_ENTITY_LIMIT,
+    MAX_ENTITY_LIMIT
+  );
+  const rankedEntities = snapshot.plan.includeEntities ? rankEntities(entityCandidates, snapshot.plan.tokens, entityLimit).map(
+    (row) => ({
+      nodeId: row.nodeId,
+      entityType: row.entityType,
+      title: row.title,
+      connectedBeliefCount: row.connectedBeliefCount,
+      connectedEvidenceCount: row.connectedEvidenceCount,
+      score: row.score,
+      ...Object.keys(row.metadata).length > 0 ? { metadata: row.metadata } : {}
+    })
+  ) : void 0;
+  let failureContext;
+  if (snapshot.plan.includeFailures && snapshot.failures) {
+    const allFailures = snapshot.failures.filter((node) => {
+      const metadata = node.metadata || {};
+      return metadata.failedApproach === true || metadata.isFailedAttempt === true;
+    });
+    const rankedFailures = rankContextSection(
+      "recentEvidence",
+      allFailures.map((node) => ({
+        id: String(node._id),
+        text: String(node.canonicalText || ""),
+        createdAt: node.createdAt || null,
+        updatedAt: node.updatedAt || node.createdAt || null
+      })),
+      snapshot.plan.tokens,
+      10,
+      snapshot.plan.rankingProfile,
+      rankOptions
+    );
+    const failures = rankedFailures.map((row) => {
+      const original = allFailures.find((node) => String(node._id) === row.id);
+      const metadata = original?.metadata || {};
+      return {
+        attemptId: row.id,
+        approach: String(row.text || ""),
+        outcome: String(metadata.errorMessage || "Failed"),
+        recordedAt: row.createdAt || referenceTimeMs || 0,
+        score: row.score
+      };
+    });
+    const failureTexts = new Set(
+      failures.map((failure) => failure.approach.toLowerCase().slice(0, 100))
+    );
+    const suppressionIds = /* @__PURE__ */ new Set();
+    if (snapshot.plan.sessionId && failureTexts.size > 0) {
+      for (const evidenceRow of recentEvidence) {
+        const evidenceText = evidenceRow.canonicalText.toLowerCase().slice(0, 100);
+        for (const failureText of failureTexts) {
+          if (evidenceText.includes(failureText) || failureText.includes(evidenceText)) {
+            suppressionIds.add(evidenceRow.nodeId);
+            break;
+          }
+        }
+      }
+    }
+    if (failures.length > 0) {
+      failureContext = {
+        failures,
+        suppressedIds: Array.from(suppressionIds)
+      };
+    }
+  }
+  const suppressionSet = new Set(failureContext?.suppressedIds || []);
+  const effectiveEvidence = suppressionSet.size > 0 ? recentEvidence.filter((row) => !suppressionSet.has(row.nodeId)) : recentEvidence;
+  const suppressedEvidenceIds = suppressionSet.size > 0 ? recentEvidence.filter((row) => suppressionSet.has(row.nodeId)).map((row) => row.nodeId) : [];
+  const summary = {
+    totalBeliefs: uniqueBeliefs.length,
+    invariants: invariants.length,
+    openQuestions: openQuestions.length,
+    evidenceItems: uniqueEvidence.length,
+    contradictions: contradictions2.length,
+    ...rankedEntities ? { relatedEntities: rankedEntities.length } : {},
+    scopedTopics: snapshot.plan.scopedTopicIds.length,
+    descendantDepth: snapshot.plan.descendantDepth,
+    query: snapshot.plan.queryText || null
+  };
+  const injectionPolicy = buildInjectionPlan({
+    tokenBudget: snapshot.plan.tokenBudget,
+    invariants: invariants.map((row) => ({
+      nodeId: row.nodeId,
+      canonicalText: row.canonicalText,
+      score: row.score
+    })),
+    activeBeliefs: activeBeliefs.map((row) => ({
+      nodeId: row.nodeId,
+      canonicalText: row.canonicalText,
+      score: row.score
+    })),
+    openQuestions: openQuestions.map((row) => ({
+      questionId: row.questionId,
+      text: row.text,
+      score: row.score
+    })),
+    recentEvidence: effectiveEvidence.map((row) => ({
+      nodeId: row.nodeId,
+      canonicalText: row.canonicalText,
+      score: row.score
+    })),
+    contradictions: contradictions2.map((row) => ({
+      contradictionId: row.contradictionId,
+      description: row.description,
+      score: row.score
+    })),
+    trackExclusions: snapshot.plan.compilationMode === "delta"
+  });
+  const contextNarrative = [
+    "Prefer invariant beliefs as hard constraints while reasoning over this scope.",
+    "Treat open questions as unresolved work items and avoid claiming closure without evidence.",
+    "Use recent evidence for implementation context before creating new beliefs.",
+    "When contradictions exist, resolve explicitly (fork, lower confidence, or gather counter-evidence).",
+    `Apply injection token budget of ${injectionPolicy.tokenBudget} with section quotas before prompt assembly.`
+  ];
+  const deltaReport = snapshot.plan.compilationMode === "delta" && snapshot.plan.worktreeId ? {
+    changedItems: [],
+    verificationObligations: [],
+    referencePoint: snapshot.plan.worktreeId
+  } : void 0;
+  const excludedItems = [
+    ...injectionPolicy.excludedItems || [],
+    ...suppressedEvidenceIds.map((id) => ({
+      id,
+      section: "recentEvidence",
+      reason: "anti_repetition",
+      score: recentEvidence.find((row) => row.nodeId === id)?.score ?? 0
+    }))
+  ];
+  const result = {
+    schemaVersion: CONTEXT_PACK_SCHEMA_VERSION,
+    topicId: snapshot.plan.topicId,
+    topicName: snapshot.topic.name || "Untitled Topic",
+    scopedTopicIds: snapshot.plan.scopedTopicIds,
+    generatedAt: referenceTimeMs,
+    rankingProfile: snapshot.plan.rankingProfile,
+    summary,
+    invariants,
+    activeBeliefs,
+    openQuestions,
+    recentEvidence: effectiveEvidence,
+    contradictions: contradictions2,
+    ...rankedEntities ? { relatedEntities: rankedEntities } : {},
+    contextNarrative,
+    injectionPolicy: {
+      ...injectionPolicy,
+      ...excludedItems.length > 0 ? { excludedItems } : {}
+    },
+    diagnostics: {
+      itemsScored: invariantCandidates.length + activeBeliefCandidates.length + openQuestionCandidates.length + evidenceCandidates.length + contradictionCandidates.length + entityCandidates.length,
+      tokenBudgetUtilization: injectionPolicy.tokenBudget === 0 ? 0 : Number(
+        (injectionPolicy.estimatedTokens / injectionPolicy.tokenBudget).toFixed(4)
+      ),
+      referenceTimeMs
+    },
+    ...snapshot.plan.compilationMode !== "standard" ? { compilationMode: snapshot.plan.compilationMode } : {},
+    ...failureContext ? { failureContext } : {},
+    ...deltaReport ? { deltaReport } : {},
+    ...snapshot.plan.packWeightOverrides && snapshot.plan.packWeightOverrides.length > 0 ? { appliedWeightOverrides: snapshot.plan.packWeightOverrides } : {}
+  };
+  assertContextPackSchema(result);
+  return result;
+}
+
+// ../sdk/src/controlObjectOwnership.ts
+var CONTROL_OBJECT_KINDS = [
+  "tenant",
+  "workspace",
+  "principal",
+  "tool",
+  "pack",
+  "ontology",
+  "belief",
+  "policy_rule"
+];
+var CONTROL_OBJECT_OWNER_SCOPES = [
+  "platform",
+  "tenant",
+  "workspace",
+  "resource"
+];
+var CONTROL_OBJECT_EDIT_SURFACES = [
+  "platform_admin",
+  "tenant_admin",
+  "workspace_admin",
+  "graph_worktree"
+];
+var CONTROL_OBJECT_INHERITANCE_RULES = [
+  "none",
+  "platform_seed_to_tenant",
+  "tenant_default_to_workspace",
+  "workspace_narrowing_only",
+  "pack_overlay_to_tenant",
+  "topic_lineage_to_resource"
+];
+var CONTROL_OBJECT_BLAST_RADII = [
+  "platform",
+  "tenant",
+  "workspace",
+  "resource"
+];
+function defineCases(cases) {
+  return cases;
+}
+var CONTROL_OBJECT_OWNERSHIP_MATRIX = {
+  tenant: defineCases([
+    {
+      caseKey: "platform-record",
+      caseLabel: "Platform Record",
+      kind: "tenant",
+      canonicalOwnerScope: "platform",
+      editSurface: "platform_admin",
+      inheritanceRule: "none",
+      blastRadius: "tenant"
+    }
+  ]),
+  workspace: defineCases([
+    {
+      caseKey: "tenant-workspace",
+      caseLabel: "Tenant Workspace",
+      kind: "workspace",
+      canonicalOwnerScope: "tenant",
+      editSurface: "tenant_admin",
+      inheritanceRule: "tenant_default_to_workspace",
+      blastRadius: "workspace"
+    }
+  ]),
+  principal: defineCases([
+    {
+      caseKey: "tenant-principal",
+      caseLabel: "Tenant Principal",
+      kind: "principal",
+      canonicalOwnerScope: "tenant",
+      editSurface: "tenant_admin",
+      inheritanceRule: "workspace_narrowing_only",
+      blastRadius: "resource"
+    }
+  ]),
+  tool: defineCases([
+    {
+      caseKey: "platform-core",
+      caseLabel: "Platform Core",
+      kind: "tool",
+      canonicalOwnerScope: "platform",
+      editSurface: "platform_admin",
+      inheritanceRule: "platform_seed_to_tenant",
+      blastRadius: "platform"
+    },
+    {
+      caseKey: "tenant-custom",
+      caseLabel: "Tenant Custom",
+      kind: "tool",
+      canonicalOwnerScope: "tenant",
+      editSurface: "tenant_admin",
+      inheritanceRule: "tenant_default_to_workspace",
+      blastRadius: "tenant"
+    }
+  ]),
+  pack: defineCases([
+    {
+      caseKey: "platform-definition",
+      caseLabel: "Platform Definition",
+      kind: "pack",
+      canonicalOwnerScope: "platform",
+      editSurface: "platform_admin",
+      inheritanceRule: "platform_seed_to_tenant",
+      blastRadius: "platform"
+    },
+    {
+      caseKey: "tenant-installation",
+      caseLabel: "Tenant Installation",
+      kind: "pack",
+      canonicalOwnerScope: "tenant",
+      editSurface: "tenant_admin",
+      inheritanceRule: "platform_seed_to_tenant",
+      blastRadius: "tenant"
+    }
+  ]),
+  ontology: defineCases([
+    {
+      caseKey: "platform-base",
+      caseLabel: "Platform Base",
+      kind: "ontology",
+      canonicalOwnerScope: "platform",
+      editSurface: "platform_admin",
+      inheritanceRule: "platform_seed_to_tenant",
+      blastRadius: "platform"
+    },
+    {
+      caseKey: "pack-overlay",
+      caseLabel: "Pack Overlay",
+      kind: "ontology",
+      canonicalOwnerScope: "platform",
+      editSurface: "platform_admin",
+      inheritanceRule: "pack_overlay_to_tenant",
+      blastRadius: "platform"
+    },
+    {
+      caseKey: "tenant-extension",
+      caseLabel: "Tenant Extension",
+      kind: "ontology",
+      canonicalOwnerScope: "tenant",
+      editSurface: "tenant_admin",
+      inheritanceRule: "topic_lineage_to_resource",
+      blastRadius: "tenant"
+    }
+  ]),
+  belief: defineCases([
+    {
+      caseKey: "topic-resource",
+      caseLabel: "Topic Resource",
+      kind: "belief",
+      canonicalOwnerScope: "resource",
+      editSurface: "graph_worktree",
+      inheritanceRule: "topic_lineage_to_resource",
+      blastRadius: "resource"
+    }
+  ]),
+  policy_rule: defineCases([
+    {
+      caseKey: "platform-baseline",
+      caseLabel: "Platform Baseline",
+      kind: "policy_rule",
+      canonicalOwnerScope: "platform",
+      editSurface: "platform_admin",
+      inheritanceRule: "platform_seed_to_tenant",
+      blastRadius: "platform"
+    },
+    {
+      caseKey: "tenant-bundle",
+      caseLabel: "Tenant Bundle",
+      kind: "policy_rule",
+      canonicalOwnerScope: "tenant",
+      editSurface: "tenant_admin",
+      inheritanceRule: "tenant_default_to_workspace",
+      blastRadius: "tenant"
+    },
+    {
+      caseKey: "workspace-override",
+      caseLabel: "Workspace Override",
+      kind: "policy_rule",
+      canonicalOwnerScope: "workspace",
+      editSurface: "workspace_admin",
+      inheritanceRule: "none",
+      blastRadius: "workspace"
+    }
+  ])
+};
+function flattenOwnershipMatrix(matrix) {
+  return CONTROL_OBJECT_KINDS.flatMap((kind) => [...matrix[kind]]);
+}
+var CONTROL_OBJECT_OWNERSHIP_ROWS = Object.freeze(
+  flattenOwnershipMatrix(CONTROL_OBJECT_OWNERSHIP_MATRIX)
+);
+var CONTROL_OBJECT_OWNERSHIP_CONTRACT = {
+  version: "1.0.0",
+  kinds: CONTROL_OBJECT_KINDS,
+  ownerScopes: CONTROL_OBJECT_OWNER_SCOPES,
+  editSurfaces: CONTROL_OBJECT_EDIT_SURFACES,
+  inheritanceRules: CONTROL_OBJECT_INHERITANCE_RULES,
+  blastRadii: CONTROL_OBJECT_BLAST_RADII,
+  matrix: CONTROL_OBJECT_OWNERSHIP_MATRIX,
+  rows: CONTROL_OBJECT_OWNERSHIP_ROWS
+};
+function listControlObjectOwnershipCases(kind) {
+  if (!kind) {
+    return CONTROL_OBJECT_OWNERSHIP_ROWS;
+  }
+  return CONTROL_OBJECT_OWNERSHIP_MATRIX[kind];
+}
+function getControlObjectOwnershipCase(kind, caseKey) {
+  return CONTROL_OBJECT_OWNERSHIP_MATRIX[kind].find(
+    (ownershipCase) => ownershipCase.caseKey === caseKey
+  );
+}
+
+// ../sdk/src/contracts/api-enums.contract.ts
+var BELIEF_STATUSES = [
+  "assumption",
+  "hypothesis",
+  "belief",
+  "fact"
+];
+var FORK_REASONS = [
+  "refinement",
+  "contradiction_response",
+  "scope_change",
+  "confidence_collapse",
+  "manual"
+];
+var CONFIDENCE_TRIGGERS = [
+  "evidence_added",
+  "evidence_removed",
+  "contradiction_detected",
+  "contradiction_resolved",
+  "agent_assessment",
+  "worktree_outcome",
+  "worktree_completed",
+  "manual",
+  "decay",
+  "fusion",
+  "discount",
+  "deduction"
+];
+var EPISTEMIC_EDGE_TYPES = [
+  "supports",
+  "informs",
+  "depends_on",
+  "derived_from",
+  "contains",
+  "tests"
+];
+var STRUCTURAL_EDGE_TYPES = [
+  "supersedes",
+  "responds_to",
+  "belongs_to",
+  "relates_to_thesis"
+];
+var EDGE_TYPES = [
+  ...EPISTEMIC_EDGE_TYPES,
+  ...STRUCTURAL_EDGE_TYPES
+];
+var REASONING_METHODS = [
+  "deductive",
+  "inductive",
+  "abductive",
+  "analogical",
+  "empirical"
+];
+var DEFEAT_TYPES = [
+  "rebuts",
+  "undercuts",
+  "undermines"
+];
+var CONTRADICTION_SEVERITIES = [
+  "low",
+  "medium",
+  "high",
+  "critical"
+];
+var CONTRADICTION_STATUSES = [
+  "unresolved",
+  "resolved",
+  "accepted"
+];
+var MERGE_OUTCOMES = [
+  "validated",
+  "invalidated",
+  "forked",
+  "inconclusive"
+];
+var WORKTREE_PHASES = [
+  "hypothesis",
+  "investigation",
+  "evaluation",
+  "resolution"
+];
+var EPISTEMIC_LAYERS = [
+  "L1",
+  "L2",
+  "L3",
+  "L4"
+];
+var JUDGMENT_TYPES = [
+  "thesis",
+  "thesis_maturity",
+  "contradiction_ruling",
+  "scope_determination",
+  "confidence_ruling"
+];
+
+// ../sdk/src/contracts/auth-session.contract.ts
+var SESSION_AUTH_MODES = [
+  "interactive_user",
+  "service_principal",
+  "tenant_api_key",
+  "session_token"
+];
+var SESSION_PRINCIPAL_TYPES = ["human", "service", "agent"];
+var SESSION_LIFECYCLE_STATUSES = [
+  "active",
+  "expired",
+  "revoked"
+];
+function inferSessionPrincipalType(principalId) {
+  if (principalId.startsWith("user:")) {
+    return "human";
+  }
+  if (principalId.startsWith("agent:")) {
+    return "agent";
+  }
+  return "service";
+}
+function normalizeDelegationChain(args) {
+  if (args.delegationChain && args.delegationChain.length > 0) {
+    return [...args.delegationChain];
+  }
+  if (!args.delegatedBy) {
+    return;
+  }
+  return [
+    {
+      principalId: args.delegatedBy,
+      principalType: args.delegatedByType ?? inferSessionPrincipalType(args.delegatedBy),
+      delegatedAt: args.delegatedAt,
+      reason: args.reason
+    }
+  ];
+}
+function lastDelegator(delegationChain) {
+  if (!delegationChain || delegationChain.length === 0) {
+    return;
+  }
+  return delegationChain[delegationChain.length - 1]?.principalId;
+}
+
+// ../sdk/src/contracts/lens-filter.contract.ts
+function isLensFilterCriteria2(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return typeof obj.version === "number" && typeof obj.kind === "string";
+}
+function isTaxonomyFilterCriteriaV12(value) {
+  if (!isLensFilterCriteria2(value)) return false;
+  return value.version === 1 && value.kind === "taxonomy";
+}
+function validateFilterCriteria2(value) {
+  if (value === void 0 || value === null) {
+    return { valid: true };
+  }
+  if (!isLensFilterCriteria2(value)) {
+    return {
+      valid: false,
+      errors: [
+        'filterCriteria must have numeric "version" and string "kind" fields'
+      ]
+    };
+  }
+  if (isTaxonomyFilterCriteriaV12(value)) {
+    return validateTaxonomyFilterV1(value);
+  }
+  const raw = value;
+  return {
+    valid: false,
+    errors: [
+      `Unsupported filter criteria: version=${raw.version}, kind=${raw.kind}`
+    ]
+  };
+}
+function validateTaxonomyFilterV1(criteria) {
+  const errors = [];
+  if (!Array.isArray(criteria.entityTypeFilters)) {
+    errors.push("entityTypeFilters must be an array");
+    return { valid: false, errors };
+  }
+  if (criteria.entityTypeFilters.length === 0) {
+    errors.push("entityTypeFilters must contain at least one entry");
+    return { valid: false, errors };
+  }
+  for (let i = 0; i < criteria.entityTypeFilters.length; i++) {
+    const filter = criteria.entityTypeFilters[i];
+    if (!filter || typeof filter.entityTypeValue !== "string") {
+      errors.push(
+        `entityTypeFilters[${i}].entityTypeValue must be a non-empty string`
+      );
+      continue;
+    }
+    if (filter.entityTypeValue.trim().length === 0) {
+      errors.push(
+        `entityTypeFilters[${i}].entityTypeValue must be a non-empty string`
+      );
+    }
+    if (filter.subtypeValues !== void 0 && !Array.isArray(filter.subtypeValues)) {
+      errors.push(`entityTypeFilters[${i}].subtypeValues must be an array`);
+    }
+  }
+  if (criteria.ontologyScope !== void 0) {
+    if (typeof criteria.ontologyScope !== "object" || criteria.ontologyScope === null) {
+      errors.push("ontologyScope must be an object");
+    }
+  }
+  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+}
+
+// ../sdk/src/contracts/lens-workflow.contract.ts
+var LENS_PERSPECTIVE_TYPES2 = [
+  "investigation",
+  "monitoring",
+  "analysis",
+  "comparison",
+  "taxonomy"
+];
+var LENS_STATUSES = ["draft", "active", "archived"];
+var LENS_TASK_TEMPLATE_PRIORITIES = [
+  "critical",
+  "high",
+  "medium",
+  "low"
+];
+var BRANCH_DEPRECATION_MESSAGE = "Branches are deprecated for operational framing. Create a workspace-scoped lens instead.";
+function inferLensPerspectiveTypeFromBranchSchema(schema) {
+  const normalized = schema?.trim().toLowerCase();
+  if (normalized === "phase") {
+    return "monitoring";
+  }
+  if (normalized === "axis" || normalized === "dimension") {
+    return "comparison";
+  }
+  if (normalized === "track") {
+    return "investigation";
+  }
+  return "analysis";
+}
+function migrateBranchToLens(args) {
+  const perspectiveType = inferLensPerspectiveTypeFromBranchSchema(args.schema);
+  return {
+    recommendedTool: "create_lens",
+    perspectiveType,
+    message: "Branches are deprecated for operational framing. Create a workspace-scoped lens with the suggested payload instead.",
+    suggestedPayload: {
+      name: args.name,
+      description: args.description,
+      topicId: args.topicId,
+      workspaceId: args.workspaceId,
+      perspectiveType
+    }
+  };
+}
+function buildDeprecatedBranchMetadata(args) {
+  return {
+    deprecated: true,
+    deprecationMessage: BRANCH_DEPRECATION_MESSAGE,
+    lensSuggestion: migrateBranchToLens(args)
+  };
+}
+
+// ../sdk/src/contracts/mcpTools.ts
+var OPERATION_MANIFEST = LUCERN_OPERATION_MANIFEST;
+var MCP_ALWAYS_ALLOWED_TOOL_NAMES = ["identity_whoami"];
+function getMcpToolExposure(toolName) {
+  return OPERATION_MANIFEST[toolName]?.surfaces.mcp ?? "none";
+}
+function decorateMcpToolContract(toolName, contract) {
+  const exposure = getMcpToolExposure(toolName);
+  if (exposure === "none") {
+    return null;
+  }
+  return exposure === "internal" || contract.internal ? { ...contract, internal: true } : contract;
+}
+function buildMcpToolContracts(options = {}) {
+  const merged = {
+    ...MCP_TOOL_CONTRACTS,
+    ...options.extensions ?? {}
+  };
+  return Object.fromEntries(
+    Object.entries(merged).flatMap(([toolName, contract]) => {
+      const decorated = decorateMcpToolContract(toolName, contract);
+      return decorated ? [[toolName, decorated]] : [];
+    })
+  );
+}
+function mcpContractToInputSchema(contract) {
+  const properties = {};
+  for (const [paramName, paramDef] of Object.entries(contract.parameters)) {
+    const prop = {
+      type: paramDef.type,
+      description: paramDef.description
+    };
+    if (paramDef.enum) {
+      prop.enum = paramDef.enum;
+    }
+    properties[paramName] = prop;
+  }
+  return {
+    type: "object",
+    properties,
+    required: contract.required
+  };
+}
+function mcpContractToManifestEntry(name, contract) {
+  return {
+    name,
+    description: contract.description,
+    inputSchema: mcpContractToInputSchema(contract),
+    internal: Boolean(contract.internal),
+    ownerModule: contract.ownerModule,
+    ontologyPrimitive: contract.ontologyPrimitive,
+    tier: contract.tier
+  };
+}
+function isMcpToolAllowed(toolName, options = {}) {
+  const contracts = options.contracts ?? buildMcpToolContracts();
+  const contract = contracts[toolName];
+  const alwaysAllowed = /* @__PURE__ */ new Set([
+    ...MCP_ALWAYS_ALLOWED_TOOL_NAMES,
+    ...options.alwaysAllowedTools ?? []
+  ]);
+  if (alwaysAllowed.has(toolName)) {
+    return true;
+  }
+  if (options.sessionType === "user" && contract?.internal) {
+    return false;
+  }
+  if (options.permittedTools !== void 0 && options.permittedTools !== null) {
+    return options.permittedTools.some((tool) => tool.toolName === toolName);
+  }
+  if (options.allowedTools === null || options.allowedTools === void 0) {
+    return true;
+  }
+  return options.allowedTools.includes(toolName);
+}
+function buildMcpToolManifest(args = {}) {
+  const contracts = args.contracts ?? buildMcpToolContracts();
+  return Object.entries(contracts).filter(([name, contract]) => {
+    if (args.visibility?.sessionType === "user" && contract.internal) {
+      return false;
+    }
+    return isMcpToolAllowed(name, {
+      ...args.visibility,
+      contracts
+    });
+  }).map(([name, contract]) => mcpContractToManifestEntry(name, contract));
+}
+
+// ../sdk/src/contracts/prompt.contract.ts
+function isLucernPrompt(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const prompt = value;
+  return typeof prompt.slug === "string" && typeof prompt.version === "string" && typeof prompt.template === "string" && Array.isArray(prompt.variables) && prompt.variables.every((entry) => typeof entry === "string") && (prompt.modelHint === "fast" || prompt.modelHint === "balanced" || prompt.modelHint === "strong") && !!prompt.metadata && typeof prompt.metadata === "object" && typeof prompt.metadata.author === "string" && typeof prompt.metadata.createdAt === "string" && typeof prompt.metadata.description === "string" && Array.isArray(prompt.metadata.tags) && prompt.metadata.tags.every((entry) => typeof entry === "string");
+}
+
+// ../sdk/src/contracts/workflow-runtime.contract.ts
+var WORKFLOW_RUNTIME_SCHEMA_VERSION = "1.0.0";
+var WORKFLOW_MUTATION_TIERS = [
+  "read_only",
+  "low_risk_write",
+  "high_risk_write"
+];
+var WORKFLOW_APPROVAL_MODES = [
+  "none",
+  "audit_only",
+  "human_required",
+  "auto_approve"
+];
+var DEFAULT_TIER_APPROVAL_MODE = {
+  read_only: "none",
+  low_risk_write: "audit_only",
+  high_risk_write: "human_required"
+};
+var WORKFLOW_ACTION_KINDS = [
+  "context_pack",
+  "integrity_check",
+  "lucern_tool",
+  "report_compile",
+  "brief_publish",
+  "notification",
+  "custom"
+];
+var WORKFLOW_HOOK_EVENTS = [
+  "schedule.tick",
+  "worktree.activated",
+  "worktree.completed",
+  "question.created",
+  "question.answered",
+  "evidence.appended",
+  "inbox.item_created"
+];
+var WORKFLOW_OUTPUT_KINDS = [
+  "engineering_brief",
+  "research_memo",
+  "strategy_artifact",
+  "inbox_summary",
+  "pipeline_brief",
+  "structured_payload"
+];
+var WORKFLOW_RUN_STATUSES = [
+  "queued",
+  "running",
+  "awaiting_approval",
+  "completed",
+  "failed",
+  "cancelled"
+];
+var WORKFLOW_TRIGGER_KINDS = [
+  "manual",
+  "schedule",
+  "hook"
+];
+var WORKFLOW_PROOF_ARTIFACT_KINDS = [
+  "report",
+  "brief",
+  "artifact",
+  "dashboard",
+  "test_evidence"
+];
+var WORKFLOW_STAFFING_HINTS = [
+  "solo",
+  "backend+tests",
+  "fullstack",
+  "mcp+tests"
+];
+var WORKFLOW_AUTO_FIX_MODES = [
+  "disabled",
+  "dry_run",
+  "safe",
+  "aggressive"
+];
+var WORKFLOW_INTEGRITY_CHECKS = [
+  "null_dependency_refs",
+  "superseded_blockers",
+  "band_order_inconsistency",
+  "sparse_shaping",
+  "failed_completed_gate"
+];
+var DEFAULT_WORKFLOW_AUTO_FIX_POLICY = {
+  mode: "disabled",
+  permittedMutationTiers: ["read_only"],
+  requireAuditTrail: true
+};
+var NIGHTLY_RECONCILIATION_WORKFLOW_ID = "workflow.pipeline_reconciliation.v1";
+var MORNING_BRIEF_WORKFLOW_ID = "workflow.morning_brief.v1";
+var CANONICAL_WORKFLOW_DEFINITIONS = [
+  {
+    workflowId: NIGHTLY_RECONCILIATION_WORKFLOW_ID,
+    version: WORKFLOW_RUNTIME_SCHEMA_VERSION,
+    title: "Nightly Pipeline Reconciliation",
+    description: "Runs deterministic integrity checks, compiles pipeline state, and emits an operator-facing reconciliation brief.",
+    trigger: {
+      kind: "schedule",
+      cadence: "daily",
+      timezone: "America/New_York"
+    },
+    staffingHint: "backend+tests",
+    proofArtifacts: [
+      {
+        kind: "report",
+        label: "Pipeline reconciliation report",
+        required: true
+      },
+      {
+        kind: "test_evidence",
+        label: "Integrity check receipt",
+        required: true
+      }
+    ],
+    autoFixPolicy: {
+      mode: "safe",
+      maxActionsPerRun: 5,
+      permittedMutationTiers: ["read_only", "low_risk_write"],
+      requireAuditTrail: true,
+      escalationGate: "gate:workflow-runtime-contract-live"
+    },
+    actions: [
+      {
+        actionId: "compile_context_pack",
+        kind: "context_pack",
+        title: "Compile pipeline context",
+        description: "Build the ranked context needed for deterministic checks.",
+        mutationTier: "read_only",
+        produces: ["structured_payload"],
+        idempotent: true,
+        approval: { mode: "none" }
+      },
+      {
+        actionId: "run_integrity_checks",
+        kind: "integrity_check",
+        title: "Run integrity checks",
+        description: "Evaluate dependency references, blockers, campaign/lane placement, shaping coverage, and completed gates.",
+        mutationTier: "read_only",
+        produces: ["structured_payload"],
+        idempotent: true,
+        approval: { mode: "none" }
+      },
+      {
+        actionId: "record_followup_questions",
+        kind: "lucern_tool",
+        title: "Record follow-up questions",
+        description: "Create or reopen operator-facing questions for integrity failures that require human review.",
+        mutationTier: "low_risk_write",
+        toolName: "create_question",
+        produces: ["pipeline_brief"],
+        approval: { mode: "audit_only", rationaleRequired: true }
+      },
+      {
+        actionId: "publish_reconciliation_brief",
+        kind: "brief_publish",
+        title: "Publish reconciliation brief",
+        description: "Emit an inbox-routed brief summarizing the nightly pipeline state and grouped blockers.",
+        mutationTier: "low_risk_write",
+        produces: ["pipeline_brief", "inbox_summary"],
+        approval: { mode: "audit_only" }
+      }
+    ],
+    hooks: [
+      {
+        hookId: "nightly-schedule",
+        event: "schedule.tick",
+        description: "Run once per nightly cadence.",
+        actionIds: [
+          "compile_context_pack",
+          "run_integrity_checks",
+          "record_followup_questions",
+          "publish_reconciliation_brief"
+        ]
+      }
+    ],
+    outputs: ["pipeline_brief", "inbox_summary", "structured_payload"],
+    integrityChecks: WORKFLOW_INTEGRITY_CHECKS
+  },
+  {
+    workflowId: MORNING_BRIEF_WORKFLOW_ID,
+    version: WORKFLOW_RUNTIME_SCHEMA_VERSION,
+    title: "Morning Brief",
+    description: "Compiles a developer-facing morning brief from graph state, overnight workflow outputs, and inbox routing preferences.",
+    trigger: {
+      kind: "schedule",
+      cadence: "daily",
+      timezone: "America/New_York"
+    },
+    staffingHint: "solo",
+    proofArtifacts: [
+      {
+        kind: "brief",
+        label: "Morning brief",
+        required: true
+      }
+    ],
+    autoFixPolicy: {
+      mode: "dry_run",
+      maxActionsPerRun: 1,
+      permittedMutationTiers: ["read_only", "low_risk_write"],
+      requireAuditTrail: true
+    },
+    actions: [
+      {
+        actionId: "compile_brief_inputs",
+        kind: "context_pack",
+        title: "Compile brief inputs",
+        description: "Read graph state, worktree state, and overnight workflow receipts.",
+        mutationTier: "read_only",
+        produces: ["structured_payload"],
+        idempotent: true,
+        approval: { mode: "none" }
+      },
+      {
+        actionId: "publish_morning_brief",
+        kind: "brief_publish",
+        title: "Publish morning brief",
+        description: "Publish a typed inbox summary with prioritized worktree and question context.",
+        mutationTier: "low_risk_write",
+        produces: ["engineering_brief", "inbox_summary"],
+        approval: { mode: "audit_only" }
+      }
+    ],
+    hooks: [
+      {
+        hookId: "morning-schedule",
+        event: "schedule.tick",
+        description: "Run once per morning cadence.",
+        actionIds: ["compile_brief_inputs", "publish_morning_brief"]
+      },
+      {
+        hookId: "worktree-complete-refresh",
+        event: "worktree.completed",
+        description: "Refresh the queued morning brief inputs when worktree outcomes land overnight.",
+        actionIds: ["compile_brief_inputs"]
+      }
+    ],
+    outputs: ["engineering_brief", "inbox_summary", "structured_payload"],
+    integrityChecks: ["sparse_shaping"]
+  }
+];
+
+// ../sdk/src/events.ts
+var DOMAIN_EVENT_VERSION = "1.0";
+var EVENT_RETENTION_DEFAULT_DAYS = 30;
+var WEBHOOK_MAX_ATTEMPTS = 5;
+var WEBHOOK_RETRY_DELAYS_MS = [1e3, 5e3, 3e4, 3e5];
+var DOMAIN_EVENT_TYPES = [
+  "belief.created",
+  "belief.forked",
+  "belief.confidence_updated",
+  "belief.archived",
+  "belief.refined",
+  "belief.contract_created",
+  "belief.contract_evaluated",
+  "belief.lineage_queried",
+  "evidence.created",
+  "evidence.linked",
+  "evidence.search_executed",
+  "question.created",
+  "question.answered",
+  "question.refined",
+  "question.status_updated",
+  "question.archived",
+  "edge.created",
+  "contradiction.flagged",
+  "worktree.created",
+  "worktree.activated",
+  "worktree.merged",
+  "worktree.targets_updated",
+  "worktree.metadata_updated",
+  "topic.created",
+  "topic.updated",
+  "topic.archived",
+  "task.created",
+  "task.completed",
+  "task.updated",
+  "ontology.bound",
+  "context.compiled",
+  "identity.key_created",
+  "identity.key_rotated",
+  "identity.key_revoked",
+  "webhook.test"
+];
+var RUNTIME_BUFFER2 = globalThis.Buffer;
+var RUNTIME_ENV = globalThis.process?.env;
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function eventPatternToRegExp(pattern) {
+  const normalized = pattern.trim();
+  if (!normalized) {
+    return /^$/;
+  }
+  if (normalized === "*") {
+    return /^.*$/;
+  }
+  const source = escapeRegex(normalized).replace(/\\\*/g, ".*");
+  return new RegExp(`^${source}$`);
+}
+function matchesEventPattern(eventType, pattern) {
+  return eventPatternToRegExp(pattern).test(eventType.trim());
+}
+function matchesAnyEventPattern(eventType, patterns) {
+  if (patterns.length === 0) {
+    return true;
+  }
+  return patterns.some((pattern) => matchesEventPattern(eventType, pattern));
+}
+function toBase64(value) {
+  if (RUNTIME_BUFFER2) {
+    return RUNTIME_BUFFER2.from(value, "utf8").toString("base64url");
+  }
+  return btoa(unescape(encodeURIComponent(value))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function fromBase64(value) {
+  if (RUNTIME_BUFFER2) {
+    return RUNTIME_BUFFER2.from(value, "base64url").toString("utf8");
+  }
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  return decodeURIComponent(escape(atob(normalized)));
+}
+function createEventId() {
+  const random = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID().replace(/-/g, "") : Array.from(
+    typeof globalThis.crypto?.getRandomValues === "function" ? globalThis.crypto.getRandomValues(new Uint8Array(16)) : Array.from({ length: 16 }, () => Math.floor(Math.random() * 256)),
+    (value) => value.toString(16).padStart(2, "0")
+  ).join("");
+  return `evt_${random}`;
+}
+function normalizeRetentionDays(value) {
+  if (!Number.isFinite(value) || typeof value !== "number" || value <= 0) {
+    return EVENT_RETENTION_DEFAULT_DAYS;
+  }
+  return Math.max(1, Math.trunc(value));
+}
+function buildDomainEvent(input) {
+  const timestamp = input.timestamp ?? Date.now();
+  const retentionDays = normalizeRetentionDays(input.retentionDays);
+  return {
+    eventId: input.eventId?.trim() || createEventId(),
+    type: input.type.trim(),
+    version: DOMAIN_EVENT_VERSION,
+    timestamp,
+    tenantId: input.tenantId?.trim() || void 0,
+    workspaceId: input.workspaceId?.trim() || void 0,
+    topicId: input.topicId.trim(),
+    resourceId: input.resourceId.trim(),
+    resourceType: input.resourceType.trim(),
+    actorId: input.actorId.trim(),
+    actorType: input.actorType,
+    data: input.data ?? {},
+    correlationId: input.correlationId?.trim() || void 0,
+    expiresAt: timestamp + retentionDays * 24 * 60 * 60 * 1e3
+  };
+}
+function compareEventCursor(left, right) {
+  if (left.timestamp !== right.timestamp) {
+    return left.timestamp - right.timestamp;
+  }
+  return left.eventId.localeCompare(right.eventId);
+}
+function encodeEventCursor(cursor) {
+  return toBase64(JSON.stringify(cursor));
+}
+function decodeEventCursor(cursor) {
+  if (!cursor || cursor.trim().length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(fromBase64(cursor.trim()));
+    if (typeof parsed.timestamp !== "number" || !Number.isFinite(parsed.timestamp) || typeof parsed.eventId !== "string" || parsed.eventId.trim().length === 0) {
+      return null;
+    }
+    return {
+      timestamp: parsed.timestamp,
+      eventId: parsed.eventId.trim()
+    };
+  } catch {
+    return null;
+  }
+}
+function isAfterCursor(event, cursor) {
+  if (!cursor) {
+    return true;
+  }
+  return compareEventCursor(event, cursor) > 0;
+}
+function sortEventsByCursor(events) {
+  return [...events].sort((left, right) => compareEventCursor(left, right));
+}
+function inferActorType(args) {
+  if (args.sessionType === "agent") {
+    return "agent";
+  }
+  if (args.authMode === "service_principal" || args.authMode === "tenant_api_key" || args.principalType === "service") {
+    return "service";
+  }
+  return "human";
+}
+async function emitDomainEvent(invokeMutation, input) {
+  return await invokeMutation("events:recordEvent", input);
+}
+var LOCALHOST_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
+function normalizeUrl(url) {
+  try {
+    return new URL(url.trim());
+  } catch {
+    throw new Error("Webhook URL must be a valid absolute URL.");
+  }
+}
+function assertValidWebhookUrl(url) {
+  const parsed = normalizeUrl(url);
+  const hostname = parsed.hostname.trim().toLowerCase();
+  const nodeEnv = RUNTIME_ENV?.NODE_ENV;
+  const allowLocalHttp = nodeEnv === "test" || LOCALHOST_HOSTS.has(hostname);
+  if (parsed.protocol !== "https:" && !(allowLocalHttp && parsed.protocol === "http:")) {
+    throw new Error("Webhook URL must use HTTPS.");
+  }
+  return parsed.toString();
+}
+function normalizeWebhookPatterns(patterns) {
+  const normalized = Array.from(
+    new Set(
+      patterns.map((pattern) => pattern.trim()).filter((pattern) => pattern.length > 0)
+    )
+  );
+  if (normalized.length === 0) {
+    throw new Error("At least one webhook event pattern is required.");
+  }
+  return normalized;
+}
+function assertValidWebhookSecret(secret) {
+  const normalized = secret.trim();
+  if (normalized.length < 8) {
+    throw new Error("Webhook secret must be at least 8 characters.");
+  }
+  return normalized;
+}
+async function computeWebhookSignature(payload, secret) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+  return Array.from(new Uint8Array(signature)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function nextDeliveryAttemptAt(currentAttemptCount, now = Date.now()) {
+  if (currentAttemptCount >= WEBHOOK_MAX_ATTEMPTS) {
+    return void 0;
+  }
+  const retryIndex = currentAttemptCount - 1;
+  const delay2 = WEBHOOK_RETRY_DELAYS_MS[retryIndex];
+  return typeof delay2 === "number" ? now + delay2 : void 0;
+}
+function resolveDeliveryFailureStatus(attemptCount) {
+  return attemptCount >= WEBHOOK_MAX_ATTEMPTS ? "dead_letter" : "failed";
+}
+function sanitizeWebhookRecord(value) {
+  return {
+    id: String(value.id ?? value.webhookId ?? value._id ?? ""),
+    webhookId: String(value.webhookId ?? value.id ?? value._id ?? ""),
+    tenantId: typeof value.tenantId === "string" && value.tenantId.trim().length > 0 ? value.tenantId : void 0,
+    workspaceId: typeof value.workspaceId === "string" && value.workspaceId.trim().length > 0 ? value.workspaceId : void 0,
+    topicId: typeof value.topicId === "string" && value.topicId.trim().length > 0 ? value.topicId : void 0,
+    url: String(value.url ?? ""),
+    events: Array.isArray(value.events) ? value.events.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean) : [],
+    active: value.active !== false,
+    secretConfigured: true,
+    createdAt: Number(value.createdAt ?? Date.now()),
+    updatedAt: Number(value.updatedAt ?? value.createdAt ?? Date.now()),
+    createdBy: String(value.createdBy ?? ""),
+    updatedBy: String(value.updatedBy ?? value.createdBy ?? ""),
+    lastDeliveryAt: typeof value.lastDeliveryAt === "number" ? value.lastDeliveryAt : void 0,
+    lastSuccessfulDeliveryAt: typeof value.lastSuccessfulDeliveryAt === "number" ? value.lastSuccessfulDeliveryAt : void 0
+  };
+}
+function truncateWebhookResponseBody(responseBody, maxLength = 2e3) {
+  if (!responseBody) {
+    return void 0;
+  }
+  if (responseBody.length <= maxLength) {
+    return responseBody;
+  }
+  return `${responseBody.slice(0, maxLength - 3)}...`;
+}
+
+// ../sdk/src/eventsCore.ts
+function serializeTypes2(types) {
+  return Array.isArray(types) && types.length > 0 ? types.join(",") : void 0;
+}
+function createEventsClientCore(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    async list(query5 = {}) {
+      return gateway.request({
+        path: `/v1/events${toQueryString({
+          topicId: query5.topicId,
+          after: query5.after,
+          types: serializeTypes2(query5.types),
+          startTime: query5.startTime,
+          endTime: query5.endTime,
+          limit: query5.limit
+        })}`
+      });
+    },
+    async replay(input, idempotencyKey = randomIdempotencyKey()) {
+      return gateway.request({
+        path: "/v1/events/replay",
+        method: "POST",
+        body: input,
+        idempotencyKey
+      });
+    }
+  };
+}
+function createWebhooksClientCore(config = {}) {
+  const gateway = createGatewayRequestClient(config);
+  return {
+    async create(input, idempotencyKey = randomIdempotencyKey()) {
+      return gateway.request({
+        path: "/v1/webhooks",
+        method: "POST",
+        body: input,
+        idempotencyKey
+      });
+    },
+    async list(query5 = {}) {
+      return gateway.request({
+        path: `/v1/webhooks${toQueryString({
+          topicId: query5.topicId
+        })}`
+      });
+    },
+    async get(id) {
+      return gateway.request({
+        path: `/v1/webhooks/${encodeURIComponent(id)}`
+      });
+    },
+    async update(id, input, idempotencyKey = randomIdempotencyKey()) {
+      return gateway.request({
+        path: `/v1/webhooks/${encodeURIComponent(id)}`,
+        method: "PATCH",
+        body: input,
+        idempotencyKey
+      });
+    },
+    async delete(id, idempotencyKey = randomIdempotencyKey()) {
+      return gateway.request({
+        path: `/v1/webhooks/${encodeURIComponent(id)}`,
+        method: "DELETE",
+        idempotencyKey
+      });
+    },
+    async test(id, input = {}, idempotencyKey = randomIdempotencyKey()) {
+      return gateway.request({
+        path: `/v1/webhooks/${encodeURIComponent(id)}/test`,
+        method: "POST",
+        body: input,
+        idempotencyKey
+      });
+    },
+    async deliveries(id, query5 = {}) {
+      return gateway.request({
+        path: `/v1/webhooks/${encodeURIComponent(id)}/deliveries${toQueryString({
+          limit: query5.limit
+        })}`
+      });
+    },
+    async health(id) {
+      return gateway.request({
+        path: `/v1/webhooks/${encodeURIComponent(id)}/health`
+      });
+    }
+  };
+}
+
+// ../sdk/src/graphIntel.ts
+var graphIntel_exports = {};
+__reExport(graphIntel_exports, graphIntel_star);
+
+// ../sdk/src/index.ts
+__reExport(src_exports, graphIntel_exports);
+
+// ../sdk/src/graphIntelligence.ts
+var graphIntelligence_exports = {};
+__export(graphIntelligence_exports, {
+  GRAPH_INTELLIGENCE_MODE_TOOL_NAMES: () => GRAPH_INTELLIGENCE_MODE_TOOL_NAMES,
+  GRAPH_INTELLIGENCE_PUBLIC_TOOL_NAMES: () => GRAPH_INTELLIGENCE_PUBLIC_TOOL_NAMES,
+  GRAPH_INTELLIGENCE_QUERIES: () => GRAPH_INTELLIGENCE_QUERIES,
+  GRAPH_INTELLIGENCE_QUERIES_WITH_TOOLS: () => GRAPH_INTELLIGENCE_QUERIES_WITH_TOOLS,
+  GRAPH_INTELLIGENCE_QUERY_CATALOG_VERSION: () => GRAPH_INTELLIGENCE_QUERY_CATALOG_VERSION,
+  GRAPH_INTELLIGENCE_QUERY_CATEGORIES: () => GRAPH_INTELLIGENCE_QUERY_CATEGORIES,
+  GRAPH_INTELLIGENCE_QUERY_MODES: () => GRAPH_INTELLIGENCE_QUERY_MODES,
+  GRAPH_INTELLIGENCE_QUICK_QUERIES: () => GRAPH_INTELLIGENCE_QUICK_QUERIES,
+  fillGraphIntelligencePromptTemplate: () => fillGraphIntelligencePromptTemplate,
+  getGraphIntelligenceQuery: () => getGraphIntelligenceQuery,
+  isGraphIntelligenceQueryMode: () => isGraphIntelligenceQueryMode,
+  listGraphIntelligenceQueries: () => listGraphIntelligenceQueries
+});
+__reExport(graphIntelligence_exports, graphIntel_exports);
+
+// ../sdk/src/index.ts
+__reExport(src_exports, graphIntelligence_exports);
+
+// src/types.ts
+var McpHandlerError = class extends Error {
+  code;
+  status;
+  suggestion;
+  constructor(message, code = "INVALID_REQUEST", status = 400, suggestion) {
+    super(message);
+    this.name = "McpHandlerError";
+    this.code = code;
+    this.status = status;
+    this.suggestion = suggestion;
+  }
+};
+
+// src/handler-factory.ts
+function isMissing(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return value.trim().length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  return false;
 }
 function readString3(params, key, options = {}) {
   const value = params[key];
@@ -24418,9 +27955,9 @@ var MCP_RATE_LIMIT_SIGNALS = [
   "RATE_LIMIT_EXCEEDED",
   "Retry-After"
 ];
-var OPERATION_MANIFEST = LUCERN_OPERATION_MANIFEST;
+var OPERATION_MANIFEST2 = LUCERN_OPERATION_MANIFEST;
 function mcpExposureFor(toolName) {
-  return OPERATION_MANIFEST[toolName]?.surfaces.mcp ?? "none";
+  return OPERATION_MANIFEST2[toolName]?.surfaces.mcp ?? "none";
 }
 function withManifestVisibility(toolName, contract) {
   return mcpExposureFor(toolName) === "internal" || contract.internal ? { ...contract, internal: true } : contract;
@@ -25767,7 +29304,7 @@ async function loadDiscoveryHandlers() {
 }
 
 // src/contextPackSchema.ts
-var CONTEXT_PACK_SCHEMA_VERSION2 = "1.0.0";
+var CONTEXT_PACK_SCHEMA_VERSION3 = "1.0.0";
 var CONTEXT_PACK_SECTION_KEYS = [
   "invariants",
   "activeBeliefs",
@@ -25775,171 +29312,171 @@ var CONTEXT_PACK_SECTION_KEYS = [
   "recentEvidence",
   "contradictions"
 ];
-function isObject(value) {
+function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isString(value) {
+function isString2(value) {
   return typeof value === "string";
 }
-function isNumber(value) {
+function isNumber2(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
-function isNullableNumber(value) {
-  return value === null || isNumber(value);
+function isNullableNumber2(value) {
+  return value === null || isNumber2(value);
 }
-function isStringArray(value) {
-  return Array.isArray(value) && value.every((entry) => isString(entry));
+function isStringArray2(value) {
+  return Array.isArray(value) && value.every((entry) => isString2(entry));
 }
-function requireObject(parent, key, errors) {
+function requireObject2(parent, key, errors) {
   const value = parent[key];
-  if (!isObject(value)) {
+  if (!isObject2(value)) {
     errors.push(`Expected '${key}' to be an object`);
     return null;
   }
   return value;
 }
-function validateBeliefArray(key, value, errors) {
+function validateBeliefArray2(key, value, errors) {
   if (!Array.isArray(value)) {
     errors.push(`Expected '${key}' to be an array`);
     return;
   }
   for (let index = 0; index < value.length; index += 1) {
     const row = value[index];
-    if (!isObject(row)) {
+    if (!isObject2(row)) {
       errors.push(`Expected '${key}[${index}]' to be an object`);
       continue;
     }
-    if (!isString(row.nodeId)) {
+    if (!isString2(row.nodeId)) {
       errors.push(`Expected '${key}[${index}].nodeId' to be a string`);
     }
-    if (!isString(row.canonicalText)) {
+    if (!isString2(row.canonicalText)) {
       errors.push(`Expected '${key}[${index}].canonicalText' to be a string`);
     }
-    if (!isNullableNumber(row.confidence)) {
+    if (!isNullableNumber2(row.confidence)) {
       errors.push(`Expected '${key}[${index}].confidence' to be number|null`);
     }
   }
 }
-function validateQuestionArray(key, value, errors) {
+function validateQuestionArray2(key, value, errors) {
   if (!Array.isArray(value)) {
     errors.push(`Expected '${key}' to be an array`);
     return;
   }
   for (let index = 0; index < value.length; index += 1) {
     const row = value[index];
-    if (!isObject(row)) {
+    if (!isObject2(row)) {
       errors.push(`Expected '${key}[${index}]' to be an object`);
       continue;
     }
-    if (!isString(row.questionId)) {
+    if (!isString2(row.questionId)) {
       errors.push(`Expected '${key}[${index}].questionId' to be a string`);
     }
-    if (!isString(row.text)) {
+    if (!isString2(row.text)) {
       errors.push(`Expected '${key}[${index}].text' to be a string`);
     }
-    if (!isString(row.status)) {
+    if (!isString2(row.status)) {
       errors.push(`Expected '${key}[${index}].status' to be a string`);
     }
   }
 }
-function validateEvidenceArray(key, value, errors) {
+function validateEvidenceArray2(key, value, errors) {
   if (!Array.isArray(value)) {
     errors.push(`Expected '${key}' to be an array`);
     return;
   }
   for (let index = 0; index < value.length; index += 1) {
     const row = value[index];
-    if (!isObject(row)) {
+    if (!isObject2(row)) {
       errors.push(`Expected '${key}[${index}]' to be an object`);
       continue;
     }
-    if (!isString(row.nodeId)) {
+    if (!isString2(row.nodeId)) {
       errors.push(`Expected '${key}[${index}].nodeId' to be a string`);
     }
-    if (!isString(row.canonicalText)) {
+    if (!isString2(row.canonicalText)) {
       errors.push(`Expected '${key}[${index}].canonicalText' to be a string`);
     }
   }
 }
-function validateEntityArray(key, value, errors) {
+function validateEntityArray2(key, value, errors) {
   if (!Array.isArray(value)) {
     errors.push(`Expected '${key}' to be an array`);
     return;
   }
   for (let index = 0; index < value.length; index += 1) {
     const row = value[index];
-    if (!isObject(row)) {
+    if (!isObject2(row)) {
       errors.push(`Expected '${key}[${index}]' to be an object`);
       continue;
     }
-    if (!isString(row.nodeId)) {
+    if (!isString2(row.nodeId)) {
       errors.push(`Expected '${key}[${index}].nodeId' to be a string`);
     }
-    if (!isString(row.entityType)) {
+    if (!isString2(row.entityType)) {
       errors.push(`Expected '${key}[${index}].entityType' to be a string`);
     }
-    if (!isString(row.title)) {
+    if (!isString2(row.title)) {
       errors.push(`Expected '${key}[${index}].title' to be a string`);
     }
-    if (!isNumber(row.connectedBeliefCount)) {
+    if (!isNumber2(row.connectedBeliefCount)) {
       errors.push(
         `Expected '${key}[${index}].connectedBeliefCount' to be a number`
       );
     }
-    if (!isNumber(row.connectedEvidenceCount)) {
+    if (!isNumber2(row.connectedEvidenceCount)) {
       errors.push(
         `Expected '${key}[${index}].connectedEvidenceCount' to be a number`
       );
     }
-    if (!isNumber(row.score)) {
+    if (!isNumber2(row.score)) {
       errors.push(`Expected '${key}[${index}].score' to be a number`);
     }
   }
 }
-function validateContradictionArray(key, value, errors) {
+function validateContradictionArray2(key, value, errors) {
   if (!Array.isArray(value)) {
     errors.push(`Expected '${key}' to be an array`);
     return;
   }
   for (let index = 0; index < value.length; index += 1) {
     const row = value[index];
-    if (!isObject(row)) {
+    if (!isObject2(row)) {
       errors.push(`Expected '${key}[${index}]' to be an object`);
       continue;
     }
-    if (!isString(row.contradictionId)) {
+    if (!isString2(row.contradictionId)) {
       errors.push(`Expected '${key}[${index}].contradictionId' to be a string`);
     }
-    if (!isString(row.status)) {
+    if (!isString2(row.status)) {
       errors.push(`Expected '${key}[${index}].status' to be a string`);
     }
   }
 }
 function validateContextPackSchema2(payload) {
   const errors = [];
-  if (!isObject(payload)) {
+  if (!isObject2(payload)) {
     return {
       valid: false,
       errors: ["Expected context pack payload to be an object"]
     };
   }
-  if (payload.schemaVersion !== CONTEXT_PACK_SCHEMA_VERSION2) {
+  if (payload.schemaVersion !== CONTEXT_PACK_SCHEMA_VERSION3) {
     errors.push(
-      `Expected schemaVersion='${CONTEXT_PACK_SCHEMA_VERSION2}', received '${String(
+      `Expected schemaVersion='${CONTEXT_PACK_SCHEMA_VERSION3}', received '${String(
         payload.schemaVersion
       )}'`
     );
   }
-  if (!isString(payload.topicId)) {
+  if (!isString2(payload.topicId)) {
     errors.push("Expected 'topicId' to be a string");
   }
-  if (!isString(payload.topicName)) {
+  if (!isString2(payload.topicName)) {
     errors.push("Expected 'topicName' to be a string");
   }
-  if (!isStringArray(payload.scopedTopicIds)) {
+  if (!isStringArray2(payload.scopedTopicIds)) {
     errors.push("Expected 'scopedTopicIds' to be string[]");
   }
-  if (!isNumber(payload.generatedAt)) {
+  if (!isNumber2(payload.generatedAt)) {
     errors.push("Expected 'generatedAt' to be a number");
   }
   if (payload.rankingProfile !== "baseline_v1" && payload.rankingProfile !== "hybrid_v1" && payload.rankingProfile !== "weighted_v1") {
@@ -25947,7 +29484,7 @@ function validateContextPackSchema2(payload) {
       "Expected 'rankingProfile' to be 'baseline_v1', 'hybrid_v1', or 'weighted_v1'"
     );
   }
-  const summary = requireObject(payload, "summary", errors);
+  const summary = requireObject2(payload, "summary", errors);
   if (summary) {
     const summaryKeys = [
       "totalBeliefs",
@@ -25958,18 +29495,18 @@ function validateContextPackSchema2(payload) {
       "scopedTopics"
     ];
     for (const key of summaryKeys) {
-      if (!isNumber(summary[key])) {
+      if (!isNumber2(summary[key])) {
         errors.push(`Expected 'summary.${key}' to be a number`);
       }
     }
   }
-  validateBeliefArray("invariants", payload.invariants, errors);
-  validateBeliefArray("activeBeliefs", payload.activeBeliefs, errors);
-  validateQuestionArray("openQuestions", payload.openQuestions, errors);
-  validateEvidenceArray("recentEvidence", payload.recentEvidence, errors);
-  validateContradictionArray("contradictions", payload.contradictions, errors);
+  validateBeliefArray2("invariants", payload.invariants, errors);
+  validateBeliefArray2("activeBeliefs", payload.activeBeliefs, errors);
+  validateQuestionArray2("openQuestions", payload.openQuestions, errors);
+  validateEvidenceArray2("recentEvidence", payload.recentEvidence, errors);
+  validateContradictionArray2("contradictions", payload.contradictions, errors);
   if (payload.relatedEntities !== void 0) {
-    validateEntityArray("relatedEntities", payload.relatedEntities, errors);
+    validateEntityArray2("relatedEntities", payload.relatedEntities, errors);
   }
   if (payload.compilationMode !== void 0 && payload.compilationMode !== "standard" && payload.compilationMode !== "delta") {
     errors.push(
@@ -25977,7 +29514,7 @@ function validateContextPackSchema2(payload) {
     );
   }
   if (payload.failureContext !== void 0) {
-    if (!isObject(payload.failureContext)) {
+    if (!isObject2(payload.failureContext)) {
       errors.push("Expected 'failureContext' to be an object");
     } else {
       const failureContext = payload.failureContext;
@@ -25990,7 +29527,7 @@ function validateContextPackSchema2(payload) {
     }
   }
   if (payload.deltaReport !== void 0) {
-    if (!isObject(payload.deltaReport)) {
+    if (!isObject2(payload.deltaReport)) {
       errors.push("Expected 'deltaReport' to be an object");
     } else {
       const deltaReport = payload.deltaReport;
@@ -26002,38 +29539,38 @@ function validateContextPackSchema2(payload) {
           "Expected 'deltaReport.verificationObligations' to be an array"
         );
       }
-      if (!isString(deltaReport.referencePoint)) {
+      if (!isString2(deltaReport.referencePoint)) {
         errors.push("Expected 'deltaReport.referencePoint' to be a string");
       }
     }
   }
   if (!Array.isArray(payload.contextNarrative)) {
     errors.push("Expected 'contextNarrative' to be an array");
-  } else if (!payload.contextNarrative.every((entry) => isString(entry))) {
+  } else if (!payload.contextNarrative.every((entry) => isString2(entry))) {
     errors.push("Expected each 'contextNarrative' entry to be a string");
   }
-  const injectionPolicy = requireObject(payload, "injectionPolicy", errors);
+  const injectionPolicy = requireObject2(payload, "injectionPolicy", errors);
   if (injectionPolicy) {
-    if (!isNumber(injectionPolicy.tokenBudget)) {
+    if (!isNumber2(injectionPolicy.tokenBudget)) {
       errors.push("Expected 'injectionPolicy.tokenBudget' to be a number");
     }
-    if (!isNumber(injectionPolicy.estimatedTokens)) {
+    if (!isNumber2(injectionPolicy.estimatedTokens)) {
       errors.push("Expected 'injectionPolicy.estimatedTokens' to be a number");
     }
-    const selected = requireObject(injectionPolicy, "selected", errors);
+    const selected = requireObject2(injectionPolicy, "selected", errors);
     if (selected) {
       for (const key of CONTEXT_PACK_SECTION_KEYS) {
-        if (!isStringArray(selected[key])) {
+        if (!isStringArray2(selected[key])) {
           errors.push(
             `Expected 'injectionPolicy.selected.${key}' to be string[]`
           );
         }
       }
     }
-    const sectionUsage = requireObject(injectionPolicy, "sectionUsage", errors);
+    const sectionUsage = requireObject2(injectionPolicy, "sectionUsage", errors);
     if (sectionUsage) {
       for (const key of CONTEXT_PACK_SECTION_KEYS) {
-        if (!isNumber(sectionUsage[key])) {
+        if (!isNumber2(sectionUsage[key])) {
           errors.push(
             `Expected 'injectionPolicy.sectionUsage.${key}' to be a number`
           );
@@ -26041,12 +29578,12 @@ function validateContextPackSchema2(payload) {
       }
     }
   }
-  const diagnostics = requireObject(payload, "diagnostics", errors);
+  const diagnostics = requireObject2(payload, "diagnostics", errors);
   if (diagnostics) {
-    if (!isNumber(diagnostics.itemsScored)) {
+    if (!isNumber2(diagnostics.itemsScored)) {
       errors.push("Expected 'diagnostics.itemsScored' to be a number");
     }
-    if (!isNumber(diagnostics.tokenBudgetUtilization)) {
+    if (!isNumber2(diagnostics.tokenBudgetUtilization)) {
       errors.push(
         "Expected 'diagnostics.tokenBudgetUtilization' to be a number"
       );