@lucern/events 0.3.0-alpha.1 → 0.3.0-alpha.10

package/dist/types.js

@@ -1,6 +1,487 @@
 import { z } from 'zod';
 import { v } from 'convex/values';
 
+// ../contracts/src/graph-intelligence.contract.ts
+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 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"
+  }
+];
+GRAPH_INTELLIGENCE_QUERIES.map((query) => {
+  const definition = query;
+  return {
+    ...definition,
+    tools: definition.tools ?? byMode(definition.mode)
+  };
+});
+
 // ../contracts/src/events.contract.ts
 var DOMAIN_EVENT_VERSION = "1.0";
 var EVENT_RETENTION_DEFAULT_DAYS = 30;
@@ -60,7 +541,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({
@@ -1545,7 +2029,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(),
@@ -1888,6 +2372,40 @@ defineTable({
     { kind: "index", name: "by_tier_window_end", columns: ["tier", "windowEndMs"] }
   ]
 });
+defineTable({
+  name: "oauthDeviceCodes",
+  component: "mc",
+  category: "identity",
+  shape: z.object({
+    "deviceCodeHash": z.string(),
+    "userCode": z.string(),
+    "clientId": z.string(),
+    "scope": z.string(),
+    "status": z.enum(["pending", "approved", "denied", "expired", "consumed"]),
+    "expiresAt": z.number(),
+    "intervalSeconds": z.number(),
+    "lastPolledAt": z.number().optional(),
+    "slowDownCount": z.number().optional(),
+    "clerkUserId": z.string().optional(),
+    "tenantId": idOf("tenants").optional(),
+    "workspaceId": z.string().optional(),
+    "principalId": z.string().optional(),
+    "role": z.string().optional(),
+    "scopes": z.array(z.string()).optional(),
+    "sessionId": z.string().optional(),
+    "approvedAt": z.number().optional(),
+    "deniedAt": z.number().optional(),
+    "consumedAt": z.number().optional(),
+    "createdAt": z.number(),
+    "updatedAt": z.number()
+  }),
+  indices: [
+    { kind: "index", name: "by_deviceCodeHash", columns: ["deviceCodeHash"] },
+    { kind: "index", name: "by_userCode", columns: ["userCode"] },
+    { kind: "index", name: "by_status_expiresAt", columns: ["status", "expiresAt"] },
+    { kind: "index", name: "by_sessionId", columns: ["sessionId"] }
+  ]
+});
 defineTable({
   name: "servicePrincipalKeys",
   component: "mc",
@@ -3720,6 +4238,7 @@ defineTable({
     "updatedAt": z.number()
   }),
   indices: [
+    { kind: "index", name: "by_globalId", columns: ["globalId"] },
     { kind: "index", name: "by_parent", columns: ["parentTopicId"] },
     { kind: "index", name: "by_type", columns: ["type"] },
     { kind: "index", name: "by_graph_scope_project", columns: ["graphScopeProjectId"] },
@@ -3844,7 +4363,9 @@ defineTable({
     "defaultProjectVisibility": z.enum(["private", "team", "firm", "external", "public"]).optional(),
     "deployments": z.record(z.object({
       "url": z.string(),
-      "encryptedDeployKey": z.string()
+      "target": z.enum(["kernelDeployment", "appDeployment"]).optional(),
+      "encryptedDeployKey": z.string().optional(),
+      "credentialRef": z.string().optional()
     })).optional(),
     "metadata": z.record(z.any()).optional(),
     "createdBy": z.string().optional(),
@@ -4194,17 +4715,44 @@ z.object({
     message: "SL invariant b+d+u=1 violated at API boundary"
   }
 );
-var EpistemicNodeTypeSchema = z.enum([
+
+// ../contracts/src/schema-helpers/spine/tables/epistemicNodes.ts
+var NODE_TYPES = [
+  "decision",
   "belief",
-  "evidence",
   "question",
-  "answer",
+  "theme",
+  "deal",
   "topic",
+  "claim",
+  "evidence",
+  "synthesis",
+  "answer",
+  "atomic_fact",
+  "excerpt",
+  "source",
+  "company",
+  "person",
+  "investor",
+  "function",
+  "value_chain"
+];
+new Set(NODE_TYPES);
+
+// ../contracts/src/types/graph-ref.ts
+var GRAPH_REF_EXTRA_NODE_TYPES = [
   "edge",
   "ontology",
   "lens",
   "contradiction"
-]);
+];
+var GRAPH_REF_NODE_TYPES = [
+  ...NODE_TYPES,
+  ...GRAPH_REF_EXTRA_NODE_TYPES
+];
+var EpistemicNodeTypeSchema = z.enum(
+  GRAPH_REF_NODE_TYPES
+);
 var GraphRefSchema = z.discriminatedUnion("kind", [
   z.object({
     kind: z.literal("epistemic_node"),
@@ -4252,34 +4800,142 @@ function assertEdgePolicyAllowed(manifest, edgeType, from, to) {
 }
 
 // ../contracts/src/manifests/edge-policy-manifest.data.ts
+var publicEpistemicNodeEdgePolicy = (edgeType) => ({
+  edgeType,
+  fromKinds: ["epistemic_node"],
+  toKinds: ["epistemic_node"],
+  description: "Canonical public create_edge policy for graph-node relationships. The policy layer gates edge-type membership, not endpoint semantics."
+});
 var edgePolicyManifest = {
-  policies: [
-    {
-      edgeType: "evidence_derived_from_evidence",
-      fromKinds: ["epistemic_node"],
-      fromNodeTypes: ["evidence"],
-      toKinds: ["epistemic_node"],
-      toNodeTypes: ["evidence"],
-      description: "Evidence E2 was synthesized from evidence E1 by a transformation. Provides chain-of-evidence lineage."
-    },
-    {
-      edgeType: "evidence_supports_belief",
-      fromKinds: ["epistemic_node"],
-      fromNodeTypes: ["evidence"],
-      toKinds: ["epistemic_node"],
-      toNodeTypes: ["belief"],
-      description: "Existing link_evidence_to_belief semantics promoted to the create_edge policy source."
-    },
-    {
-      edgeType: "evidence_supports_question",
-      fromKinds: ["epistemic_node"],
-      fromNodeTypes: ["evidence"],
-      toKinds: ["epistemic_node"],
-      toNodeTypes: ["question"],
-      description: "Existing link_evidence_to_question semantics promoted to the create_edge policy source."
-    }
-  ]
+  policies: EDGE_TYPE_VALUES.map(publicEpistemicNodeEdgePolicy)
 };
+
+// ../contracts/src/tenant-client.contract.ts
+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/graph-sync",
+    role: "host_addon_runtime",
+    directTenantImport: true
+  },
+  {
+    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
+);
 z.object({
   manifestVersion: z.literal("1.0.0"),
   rules: z.array(
@@ -4340,8 +4996,11 @@ function compactRecord(input) {
     Object.entries(input).filter(([, value]) => value !== void 0)
   );
 }
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 function recordValue(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  return isRecord(value) ? value : {};
 }
 var createEvidenceProjection = defineProjection({
   contractName: "create_evidence",
@@ -5041,7 +5700,22 @@ var ADD_WORKTREE = {
   description: "Check out a branch into an active worktree for investigation. Like `git worktree add <branch>` \u2014 creates independent working state on a thematic branch. Beliefs committed within the worktree can be freely amended (draft code on a feature branch). When investigation is complete, `merge` integrates findings into main.",
   parameters: {
     title: { type: "string", description: "Worktree name/objective" },
-    topicId: { type: "string", description: "Optional topic scope hint" },
+    name: {
+      type: "string",
+      description: "Optional storage-name alias for callers that already use backend naming"
+    },
+    projectId: {
+      type: "string",
+      description: "Legacy topicId alias or resolver hint"
+    },
+    topicId: {
+      type: "string",
+      description: "Optional topic scope hint for resolver validation"
+    },
+    topicHint: {
+      type: "string",
+      description: "Natural-language topic hint for automatic topic resolution"
+    },
     branchId: {
       type: "string",
       description: "The branch this worktree investigates"
@@ -5054,18 +5728,107 @@ var ADD_WORKTREE = {
       type: "string",
       description: "The testable claim this worktree investigates"
     },
+    rationale: {
+      type: "string",
+      description: "Why this worktree exists and why it belongs in the campaign"
+    },
+    worktreeType: {
+      type: "string",
+      description: "Schema-enum worktree type used by the kernel lifecycle and retrieval layers"
+    },
+    gate: {
+      type: "string",
+      description: "Exit gate name for this worktree"
+    },
+    startDate: {
+      type: "number",
+      description: "Planned start timestamp in milliseconds since epoch"
+    },
+    endDate: {
+      type: "number",
+      description: "Planned end timestamp in milliseconds since epoch"
+    },
+    durationWeeks: {
+      type: "number",
+      description: "Planned duration in weeks"
+    },
+    confidenceImpact: {
+      type: "string",
+      description: "Expected confidence impact if the worktree succeeds",
+      enum: ["high", "medium", "low"]
+    },
+    beliefFocus: {
+      type: "string",
+      description: "Natural-language focus spanning the target belief neighborhood"
+    },
     beliefIds: {
       type: "array",
-      description: "Beliefs to test in this worktree"
+      description: "Legacy alias for targetBeliefIds"
+    },
+    beliefs: {
+      type: "array",
+      description: "Legacy alias for targetBeliefIds"
+    },
+    targetBeliefIds: {
+      type: "array",
+      description: "Belief node IDs this worktree is expected to test or update"
+    },
+    targetQuestionIds: {
+      type: "array",
+      description: "Question node IDs this worktree is expected to answer"
+    },
+    keyQuestions: {
+      type: "array",
+      description: "Inline key question objects with question, optional status, answer, answerConfidence, and linkedQuestionId"
+    },
+    evidenceSignals: {
+      type: "array",
+      description: "Evidence signal objects with signal, optional collected state, progress, and notes"
+    },
+    decisionGate: {
+      type: "object",
+      description: "Decision gate object with goCriteria, noGoSignals, optional verdict, rationale, decidedAt, and decidedBy"
+    },
+    goCriteria: {
+      type: "array",
+      description: "Shorthand go criteria used to build decisionGate"
+    },
+    noGoSignals: {
+      type: "array",
+      description: "Shorthand no-go signals used to build decisionGate"
+    },
+    proofArtifacts: {
+      type: "array",
+      description: "Expected proof artifacts required to close the worktree"
     },
     autoShape: {
       type: "boolean",
       description: "Whether to invoke inquiry auto-shaping during worktree creation"
     },
+    autoFixPolicy: {
+      type: "object",
+      description: "Policy for permitted automatic remediation inside the worktree"
+    },
     domainPackId: {
       type: "string",
       description: "Optional domain pack whose shaping hooks should influence generated questions and tasks"
     },
+    tags: {
+      type: "array",
+      description: "Additional topic-resolution tags for the worktree"
+    },
+    touchedPaths: {
+      type: "array",
+      description: "File paths used as topic-resolution signals"
+    },
+    sourceRef: {
+      type: "string",
+      description: "Source reference used as a topic-resolution signal"
+    },
+    sourceKind: {
+      type: "string",
+      description: "Source kind used as a topic-resolution signal"
+    },
     campaign: {
       type: "number",
       description: "Top-level pipeline campaign number. Campaigns define the outer execution slice."
@@ -5090,13 +5853,21 @@ var ADD_WORKTREE = {
       type: "array",
       description: "Worktree IDs blocked by this worktree"
     },
-    gate: {
+    staffingHint: {
       type: "string",
-      description: "Exit gate name for this worktree"
-    }
-  },
-  required: ["title", "topicId"],
-  response: {
+      description: "Suggested staffing or agent allocation note"
+    },
+    lensId: {
+      type: "string",
+      description: "Lens that scopes this worktree when applicable"
+    },
+    lastReconciledAt: {
+      type: "number",
+      description: "Timestamp when worktree metadata was last reconciled"
+    }
+  },
+  required: ["title"],
+  response: {
     description: "The created worktree",
     fields: {
       worktreeId: "string",
@@ -5122,7 +5893,7 @@ var MERGE = {
     worktreeId: { type: "string", description: "The worktree to merge" },
     outcomes: {
       type: "array",
-      description: "Scoring outcomes for each belief: { beliefId, confidence, rationale }"
+      description: "Merge outcomes as key-finding strings, or scoring outcomes for beliefs: { beliefId, confidence, rationale }"
     },
     summary: { type: "string", description: "Overall findings summary" }
   },
@@ -5340,19 +6111,23 @@ var FIND_CONTRADICTIONS = {
 };
 var CREATE_EDGE = {
   name: "create_edge",
-  description: "Commit a typed relationship between two nodes in the reasoning graph. Like `git commit` \u2014 an atomic write that declares a dependency between nodes. The engine enforces layer transition rules \u2014 for example, L1 \u2192 L3 direct edges are forbidden (must go through L2).",
+  description: "Commit a typed relationship between two nodes in the reasoning graph. Like `git commit` \u2014 an atomic write that declares a dependency between nodes. Accepts any public epistemic edge type between public graph node refs so agents can author the full spine.",
   parameters: {
-    sourceId: {
-      type: "string",
-      description: "Source node of the relationship"
+    from: {
+      type: "object",
+      description: "Source graph ref, e.g. { kind: 'epistemic_node', nodeId: '...', nodeType: 'topic' }"
     },
-    targetId: {
-      type: "string",
-      description: "Target node of the relationship"
+    to: {
+      type: "object",
+      description: "Target graph ref, e.g. { kind: 'epistemic_node', nodeId: '...', nodeType: 'belief' }"
     },
     edgeType: {
       type: "string",
-      description: "Relationship type (informs, tests, depends_on, supersedes, etc.)"
+      description: "Relationship type from the public epistemic edge enum."
+    },
+    globalId: {
+      type: "string",
+      description: "Optional idempotent edge global ID."
     },
     weight: {
       type: "number",
@@ -5363,9 +6138,13 @@ var CREATE_EDGE = {
       type: "string",
       description: "How this was determined",
       enum: ["deductive", "inductive", "abductive", "analogical", "empirical"]
+    },
+    metadata: {
+      type: "object",
+      description: "Optional edge metadata."
     }
   },
-  required: ["sourceId", "targetId", "edgeType"],
+  required: ["from", "to", "edgeType"],
   response: {
     description: "The created edge",
     fields: {
@@ -5379,6 +6158,240 @@ var CREATE_EDGE = {
   ontologyPrimitive: "edge",
   tier: "showcase"
 };
+var UPDATE_EDGE = {
+  name: "update_edge",
+  description: "Amend metadata on an existing graph edge. Like `git commit --amend` \u2014 changes the edge annotation without recreating the relationship.",
+  parameters: {
+    edgeId: { type: "string", description: "Edge ID or global ID to update" },
+    weight: { type: "number", description: "Updated edge weight" },
+    confidence: { type: "number", description: "Updated confidence" },
+    context: { type: "string", description: "Updated human-readable context" },
+    derivationType: { type: "string", description: "Updated derivation type" },
+    metadata: { type: "object", description: "Updated metadata" }
+  },
+  required: ["edgeId"],
+  response: {
+    description: "Edge update result",
+    fields: { success: "boolean" }
+  },
+  ownerModule: "graph-primitives",
+  ontologyPrimitive: "edge",
+  tier: "workhorse"
+};
+var REMOVE_EDGE = {
+  name: "remove_edge",
+  description: "Remove one graph edge by ID. Like `git rm` \u2014 deletes a single explicit relationship from the spine.",
+  parameters: {
+    edgeId: { type: "string", description: "Edge ID or global ID to remove" }
+  },
+  required: ["edgeId"],
+  response: {
+    description: "Edge removal result",
+    fields: { success: "boolean" }
+  },
+  ownerModule: "graph-primitives",
+  ontologyPrimitive: "edge",
+  tier: "workhorse"
+};
+var REMOVE_EDGES_BETWEEN = {
+  name: "remove_edges_between",
+  description: "Remove graph edges between two nodes. Like `git rm <pathspec>` \u2014 deletes relationships matching a source, target, and optional type.",
+  parameters: {
+    fromNodeId: { type: "string", description: "Source node ID or global ID" },
+    toNodeId: { type: "string", description: "Target node ID or global ID" },
+    edgeType: { type: "string", description: "Optional edge type filter" }
+  },
+  required: ["fromNodeId", "toNodeId"],
+  response: {
+    description: "Matched edge removal result",
+    fields: { deleted: "number" }
+  },
+  ownerModule: "graph-primitives",
+  ontologyPrimitive: "edge",
+  tier: "workhorse"
+};
+var BATCH_CREATE_EDGES = {
+  name: "batch_create_edges",
+  description: "Commit multiple typed graph edges. Like `git commit` with many staged paths \u2014 writes a batch of explicit relationships atomically per edge.",
+  parameters: {
+    edges: {
+      type: "array",
+      description: "Edges to create, each with from, to, edgeType, and optional weight/confidence/context."
+    },
+    skipLayerValidation: {
+      type: "boolean",
+      description: "Skip kernel layer validation for trusted materialization flows."
+    }
+  },
+  required: ["edges"],
+  response: {
+    description: "Batch edge creation result",
+    fields: {
+      created: "number",
+      results: "array",
+      errors: "array"
+    }
+  },
+  ownerModule: "graph-primitives",
+  ontologyPrimitive: "edge",
+  tier: "workhorse"
+};
+var CREATE_EPISTEMIC_NODE = {
+  name: "create_epistemic_node",
+  description: "Commit a generic epistemic graph node. Like `git commit` \u2014 creates a canonical node in the public spine for topics, beliefs, evidence, questions, answers, sources, and entities.",
+  parameters: {
+    globalId: { type: "string", description: "Optional idempotent node global ID" },
+    nodeType: { type: "string", description: "Public epistemic node type" },
+    canonicalText: { type: "string", description: "Canonical node text" },
+    text: { type: "string", description: "Alias for canonicalText" },
+    contentHash: { type: "string", description: "Optional idempotency content hash" },
+    sourceType: { type: "string", description: "Source type for provenance" },
+    topicId: { type: "string", description: "Optional topic scope" },
+    content: { type: "string", description: "Extended content" },
+    title: { type: "string", description: "Display title" },
+    metadata: { type: "object", description: "Optional node metadata" }
+  },
+  required: ["nodeType"],
+  response: {
+    description: "Created node result",
+    fields: {
+      nodeId: "string",
+      nodeGlobalId: "string",
+      isDuplicate: "boolean"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "showcase"
+};
+var GET_EPISTEMIC_NODE = {
+  name: "get_epistemic_node",
+  description: "Read one epistemic graph node. Like `git show` \u2014 resolves a canonical spine node by ID or global ID.",
+  parameters: {
+    nodeId: { type: "string", description: "Node ID or global ID" }
+  },
+  required: ["nodeId"],
+  response: {
+    description: "The resolved node",
+    fields: { node: "object" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var LIST_EPISTEMIC_NODES = {
+  name: "list_epistemic_nodes",
+  description: "List epistemic graph nodes. Like `git ls-tree` \u2014 lists canonical spine nodes by topic, type, status, or search query.",
+  parameters: {
+    topicId: { type: "string", description: "Optional topic scope" },
+    nodeType: { type: "string", description: "Optional node type filter" },
+    status: { type: "string", description: "Optional lifecycle status" },
+    searchQuery: { type: "string", description: "Optional text search query" },
+    limit: { type: "number", description: "Maximum nodes to return" }
+  },
+  required: [],
+  response: {
+    description: "Matching nodes",
+    fields: { nodes: "array" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var UPDATE_EPISTEMIC_NODE = {
+  name: "update_epistemic_node",
+  description: "Amend an epistemic graph node. Like `git commit --amend` \u2014 updates mutable node metadata, text, status, or verification fields.",
+  parameters: {
+    nodeId: { type: "string", description: "Node ID or global ID" },
+    canonicalText: { type: "string", description: "Updated canonical text" },
+    text: { type: "string", description: "Alias for canonicalText" },
+    contentHash: { type: "string", description: "Updated content hash" },
+    content: { type: "string", description: "Updated content" },
+    title: { type: "string", description: "Updated display title" },
+    metadata: { type: "object", description: "Updated metadata" },
+    confidence: { type: "number", description: "Updated confidence" },
+    verificationStatus: { type: "string", description: "Updated verification status" },
+    status: { type: "string", description: "Updated lifecycle status" }
+  },
+  required: ["nodeId"],
+  response: {
+    description: "Node update result",
+    fields: { success: "boolean" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var ARCHIVE_EPISTEMIC_NODE = {
+  name: "archive_epistemic_node",
+  description: "Archive an epistemic graph node. Like `git rm --cached` \u2014 removes a node from active traversal without hard-deleting it.",
+  parameters: {
+    nodeId: { type: "string", description: "Node ID or global ID" }
+  },
+  required: ["nodeId"],
+  response: {
+    description: "Archive result",
+    fields: { success: "boolean", effectiveStatus: "string" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var VERIFY_EPISTEMIC_NODE = {
+  name: "verify_epistemic_node",
+  description: "Record verification state on an epistemic graph node. Like `git tag` \u2014 marks the node with a reviewed verification state.",
+  parameters: {
+    nodeId: { type: "string", description: "Node ID or global ID" },
+    verificationStatus: { type: "string", description: "Verification status" },
+    confidence: { type: "number", description: "Optional confidence update" }
+  },
+  required: ["nodeId", "verificationStatus"],
+  response: {
+    description: "Verification result",
+    fields: { success: "boolean" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var SUPERSEDE_EPISTEMIC_NODE = {
+  name: "supersede_epistemic_node",
+  description: "Supersede an epistemic graph node with a new version. Like `git commit --amend` on an immutable history branch \u2014 creates the replacement and marks the old node superseded.",
+  parameters: {
+    oldNodeId: { type: "string", description: "Node ID or global ID to supersede" },
+    newGlobalId: { type: "string", description: "Optional replacement global ID" },
+    newCanonicalText: { type: "string", description: "Replacement canonical text" },
+    text: { type: "string", description: "Alias for newCanonicalText" },
+    newContentHash: { type: "string", description: "Optional replacement content hash" },
+    reason: { type: "string", description: "Reason for superseding" }
+  },
+  required: ["oldNodeId"],
+  response: {
+    description: "Supersede result",
+    fields: { oldNodeId: "string", newNodeId: "string" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var BATCH_CREATE_EPISTEMIC_NODES = {
+  name: "batch_create_epistemic_nodes",
+  description: "Commit multiple epistemic graph nodes. Like `git commit` with many staged files \u2014 writes a batch of canonical spine nodes.",
+  parameters: {
+    nodes: {
+      type: "array",
+      description: "Nodes to create with nodeType, canonicalText/text, and optional metadata."
+    }
+  },
+  required: ["nodes"],
+  response: {
+    description: "Batch node creation result",
+    fields: { created: "number", results: "array" }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
 var RECORD_JUDGMENT = {
   name: "record_judgment",
   description: "Record a judgment \u2014 an irreversible commitment based on the current epistemic state. Like a `git tag` marking a release. A judgment synthesizes beliefs, evidence, and uncertainties into a determination. Once issued, a judgment is evaluated against the epistemic state that existed when it was made (knowledge horizon evaluation, Invariant #10).",
@@ -5676,6 +6689,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.",
@@ -6524,15 +7605,15 @@ var IDENTITY_WHOAMI = {
 };
 var COMPILE_CONTEXT = {
   name: "compile_context",
-  description: "Compile a focused reasoning context for a topic. Like `git log --graph --decorate` for the reasoning substrate \u2014 returns the canonical Pillar 3 context pack through the public API shape.",
+  description: "Compile a focused reasoning context. If topicId is omitted, Lucern resolves the best topic from the query. Like `git log --graph --decorate` for the reasoning substrate \u2014 returns the canonical Pillar 3 context pack through the public API shape.",
   parameters: {
     topicId: {
       type: "string",
-      description: "Topic scope ID to compile"
+      description: "Optional topic scope ID. Omit to resolve the topic from query."
     },
     query: {
       type: "string",
-      description: "Optional focus query used to rank context items"
+      description: "Focus query used to resolve the topic and rank context items. Required when topicId is omitted."
     },
     budget: {
       type: "number",
@@ -6556,7 +7637,7 @@ var COMPILE_CONTEXT = {
       description: "Include related ontological entities in the compiled result"
     }
   },
-  required: ["topicId"],
+  required: [],
   response: {
     description: "Compiled context pack for the requested topic",
     fields: {
@@ -6730,18 +7811,60 @@ var CREATE_TASK = {
   name: "create_task",
   description: "Create an execution task tied to the reasoning state. Like `git task` \u2014 tracks concrete work items (calls to make, data to gather, analyses to run) linked to questions, beliefs, or worktrees.",
   parameters: {
-    title: { type: "string", description: "Task description" },
+    title: { type: "string", description: "Task title" },
     topicId: { type: "string", description: "Topic scope" },
+    description: {
+      type: "string",
+      description: "Long-form task description"
+    },
     taskType: {
       type: "string",
-      description: "Type: research, interview, analysis, data_collection",
-      enum: ["research", "interview", "analysis", "data_collection"]
+      description: "Task taxonomy",
+      enum: [
+        "general",
+        "find_evidence",
+        "verify_claim",
+        "research",
+        "review",
+        "interview",
+        "analysis",
+        "track_metrics"
+      ]
+    },
+    priority: {
+      type: "string",
+      description: "Priority",
+      enum: ["urgent", "high", "medium", "low"]
+    },
+    status: {
+      type: "string",
+      description: "Initial status (defaults to todo)",
+      enum: ["todo", "in_progress", "blocked", "done"]
+    },
+    linkedWorktreeId: {
+      type: "string",
+      description: "Worktree this task belongs to"
+    },
+    linkedBeliefId: {
+      type: "string",
+      description: "Belief this task supports"
     },
     linkedQuestionId: {
       type: "string",
       description: "Question this task addresses"
     },
-    linkedWorktreeId: { type: "string", description: "Worktree scope" }
+    assigneeId: {
+      type: "string",
+      description: "Principal assigned to the task"
+    },
+    dueDate: {
+      type: "number",
+      description: "Due date as epoch milliseconds"
+    },
+    tags: {
+      type: "array",
+      description: "Free-form string tags"
+    }
   },
   required: ["title"],
   response: {
@@ -6861,6 +7984,10 @@ var CREATE_TOPIC = {
   name: "create_topic",
   description: "Create a new topic container for scoping knowledge. Like `git init` \u2014 initializes a new repository for a knowledge domain. Topics are hierarchical: a deal topic can nest under a theme topic. Types: domain, theme, deal, strategy, constitution, project, portfolio.",
   parameters: {
+    globalId: {
+      type: "string",
+      description: "Optional idempotent topic global ID"
+    },
     name: { type: "string", description: "Topic name" },
     type: {
       type: "string",
@@ -6871,6 +7998,18 @@ var CREATE_TOPIC = {
       type: "string",
       description: "Optional parent topic for nesting"
     },
+    parentTopicGlobalId: {
+      type: "string",
+      description: "Optional parent topic global ID for nesting"
+    },
+    tenantId: { type: "string", description: "Optional tenant scope" },
+    workspaceId: { type: "string", description: "Optional workspace scope" },
+    visibility: {
+      type: "string",
+      description: "Topic visibility",
+      enum: ["private", "team", "firm", "external", "public"]
+    },
+    metadata: { type: "object", description: "Optional topic metadata" },
     createdBy: { type: "string", description: "Who created this topic" }
   },
   required: ["name", "type"],
@@ -6879,6 +8018,9 @@ var CREATE_TOPIC = {
     fields: {
       id: "string \u2014 topic ID",
       globalId: "string \u2014 globally unique ID",
+      topicGlobalId: "string \u2014 topic global ID",
+      epistemicNodeId: "string \u2014 materialized topic node ID",
+      epistemicNodeGlobalId: "string \u2014 materialized topic node global ID",
       depth: "number \u2014 nesting depth"
     }
   },
@@ -7009,6 +8151,65 @@ var GET_TOPIC_TREE = {
   ontologyPrimitive: "graph",
   tier: "workhorse"
 };
+var MATERIALIZE_TOPIC_GRAPH = {
+  name: "materialize_topic_graph",
+  description: "Backfill the topic graph spine. Like `git fsck --connectivity-only` with repair enabled \u2014 creates missing topic nodes and parent-child edges idempotently.",
+  parameters: {
+    rootTopicId: {
+      type: "string",
+      description: "Optional root topic for a bounded materialization pass"
+    },
+    dryRun: {
+      type: "boolean",
+      description: "When true, report missing rows without writing them"
+    }
+  },
+  required: [],
+  response: {
+    description: "Topic graph materialization counts",
+    fields: {
+      topicsSeen: "number",
+      nodesCreated: "number",
+      nodesExisting: "number",
+      edgesCreated: "number",
+      edgesExisting: "number",
+      errors: "array"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
+var GET_TOPIC_GRAPH_SPINE = {
+  name: "get_topic_graph_spine",
+  description: "Verify the topic graph spine. Like `git fsck` \u2014 reads topics, materialized topic nodes, parent-child edges, and missing spine rows.",
+  parameters: {
+    rootTopicId: {
+      type: "string",
+      description: "Optional root topic for a bounded verifier pass"
+    },
+    includeTopicBeliefEdges: {
+      type: "boolean",
+      description: "Include topic -> belief edges in the verifier payload"
+    }
+  },
+  required: [],
+  response: {
+    description: "Topic graph spine verification payload",
+    fields: {
+      ok: "boolean",
+      counts: "object",
+      topics: "array",
+      topicNodes: "array",
+      parentEdges: "array",
+      missingTopicNodes: "array",
+      missingParentEdges: "array"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "workhorse"
+};
 var GET_CODE_CONTEXT = {
   name: "get_code_context",
   description: "Returns code-grounded beliefs, contracts, migration states, and failed attempts anchored to a specific file or function path. Like `git log -- <path>` \u2014 filters the knowledge graph to nodes anchored to a file path via metadata.codeAnchors. Results are separated by coding belief type: decisions, contracts, migrations, patterns, deprecations, and failures.",
@@ -8141,27 +9342,90 @@ var GENERATE_SESSION_HANDOFF = {
   tier: "showcase",
   internal: true
 };
-var MCP_TOOL_CONTRACTS = {
-  // Belief lifecycle (commit, amend, fork, archive)
-  create_belief: CREATE_BELIEF,
-  get_belief: GET_BELIEF,
-  refine_belief: REFINE_BELIEF,
-  modulate_confidence: MODULATE_CONFIDENCE,
-  fork_belief: FORK_BELIEF,
-  archive_belief: ARCHIVE_BELIEF,
-  create_epistemic_contract: CREATE_EPISTEMIC_CONTRACT,
-  evaluate_contract: EVALUATE_CONTRACT,
-  get_contract_status: GET_CONTRACT_STATUS,
-  // Evidence (commit)
-  create_evidence: CREATE_EVIDENCE,
-  get_evidence: GET_EVIDENCE,
-  list_evidence: LIST_EVIDENCE,
-  link_evidence: LINK_EVIDENCE,
-  add_evidence: ADD_EVIDENCE,
-  // Contradictions (merge conflict)
-  flag_contradiction: FLAG_CONTRADICTION,
-  // Lens lifecycle (workspace-scoped operational frames)
-  create_lens: CREATE_LENS,
+var BEGIN_BUILD_SESSION = {
+  name: "begin_build_session",
+  description: "Bootstrap a coding build session for a Lucern worktree. Like `git worktree add` plus `git status` \u2014 returns the compact context packet an agent needs before editing.",
+  parameters: {
+    worktreeId: {
+      type: "string",
+      description: "The Lucern worktree ID to bootstrap."
+    },
+    branch: {
+      type: "string",
+      description: "Optional git branch name. Auto-generated from the worktree name when omitted."
+    },
+    branchBase: {
+      type: "string",
+      description: 'Base branch for the feature branch. Default: "staging".'
+    },
+    prBase: {
+      type: "string",
+      description: 'Target branch for the PR. Default: "staging".'
+    },
+    sessionMode: {
+      type: "string",
+      description: 'Session mode: "async" for Codex/headless or "interactive" for live sessions.',
+      enum: ["async", "interactive"]
+    },
+    activateIfPlanning: {
+      type: "boolean",
+      description: "When true, automatically activate a planning worktree during bootstrap."
+    }
+  },
+  required: ["worktreeId"],
+  response: {
+    description: "A compact build-session packet with worktree metadata, graph anchors, questions, dependencies, and git defaults.",
+    fields: {
+      topicId: "string \u2014 canonical topic scope",
+      topicName: "string \u2014 human-readable topic name",
+      worktreeId: "string \u2014 worktree ID",
+      worktreeName: "string \u2014 human-readable worktree name",
+      branch: "string \u2014 git branch name",
+      branchBase: "string \u2014 base branch",
+      prBase: "string \u2014 PR target branch",
+      campaign: "number | null \u2014 top-level pipeline campaign",
+      lane: "string \u2014 campaign lane",
+      gate: "string \u2014 exit gate",
+      hypothesis: "string \u2014 worktree hypothesis",
+      focus: "string \u2014 session focus",
+      status: "string \u2014 worktree status after optional activation",
+      sessionMode: "string \u2014 async | interactive",
+      targetBeliefIds: "array \u2014 scoped belief IDs",
+      targetQuestionIds: "array \u2014 scoped question IDs",
+      topBeliefs: "array \u2014 highest-confidence scoped beliefs",
+      openQuestions: "array \u2014 open scoped questions",
+      resolvedDecisions: "array \u2014 answered questions summarized for the session",
+      dependencies: "array \u2014 upstream worktrees",
+      unblocks: "array \u2014 downstream worktrees",
+      mergeOrderNotes: "string \u2014 merge ordering advisory"
+    }
+  },
+  ownerModule: "bootstrap",
+  ontologyPrimitive: "worktree",
+  tier: "showcase",
+  internal: true
+};
+var MCP_TOOL_CONTRACTS = {
+  // Belief lifecycle (commit, amend, fork, archive)
+  create_belief: CREATE_BELIEF,
+  get_belief: GET_BELIEF,
+  refine_belief: REFINE_BELIEF,
+  modulate_confidence: MODULATE_CONFIDENCE,
+  fork_belief: FORK_BELIEF,
+  archive_belief: ARCHIVE_BELIEF,
+  create_epistemic_contract: CREATE_EPISTEMIC_CONTRACT,
+  evaluate_contract: EVALUATE_CONTRACT,
+  get_contract_status: GET_CONTRACT_STATUS,
+  // Evidence (commit)
+  create_evidence: CREATE_EVIDENCE,
+  get_evidence: GET_EVIDENCE,
+  list_evidence: LIST_EVIDENCE,
+  link_evidence: LINK_EVIDENCE,
+  add_evidence: ADD_EVIDENCE,
+  // Contradictions (merge conflict)
+  flag_contradiction: FLAG_CONTRADICTION,
+  // Lens lifecycle (workspace-scoped operational frames)
+  create_lens: CREATE_LENS,
   list_lenses: LIST_LENSES,
   apply_lens_to_topic: APPLY_LENS_TO_TOPIC,
   remove_lens_from_topic: REMOVE_LENS_FROM_TOPIC,
@@ -8183,11 +9447,26 @@ var MCP_TOOL_CONTRACTS = {
   bisect_confidence: BISECT_CONFIDENCE,
   // Edges (commit)
   create_edge: CREATE_EDGE,
+  update_edge: UPDATE_EDGE,
+  remove_edge: REMOVE_EDGE,
+  remove_edges_between: REMOVE_EDGES_BETWEEN,
+  batch_create_edges: BATCH_CREATE_EDGES,
+  // Epistemic node spine (commit/amend/show)
+  create_epistemic_node: CREATE_EPISTEMIC_NODE,
+  get_epistemic_node: GET_EPISTEMIC_NODE,
+  list_epistemic_nodes: LIST_EPISTEMIC_NODES,
+  update_epistemic_node: UPDATE_EPISTEMIC_NODE,
+  archive_epistemic_node: ARCHIVE_EPISTEMIC_NODE,
+  verify_epistemic_node: VERIFY_EPISTEMIC_NODE,
+  supersede_epistemic_node: SUPERSEDE_EPISTEMIC_NODE,
+  batch_create_epistemic_nodes: BATCH_CREATE_EPISTEMIC_NODES,
   // Judgments (tag)
   record_judgment: RECORD_JUDGMENT,
   // Graph intelligence (showcase)
   detect_confirmation_bias: DETECT_CONFIRMATION_BIAS,
   get_graph_structure_analysis: GET_GRAPH_STRUCTURE_ANALYSIS,
+  list_graph_intelligence_queries: LIST_GRAPH_INTELLIGENCE_QUERIES,
+  run_graph_intelligence_query: RUN_GRAPH_INTELLIGENCE_QUERY,
   get_falsification_questions: GET_FALSIFICATION_QUESTIONS,
   // Evidence operations (workhorse)
   search_evidence: SEARCH_EVIDENCE,
@@ -8234,6 +9513,7 @@ var MCP_TOOL_CONTRACTS = {
   get_agent_inbox: GET_AGENT_INBOX,
   claim_files: CLAIM_FILES,
   generate_session_handoff: GENERATE_SESSION_HANDOFF,
+  begin_build_session: BEGIN_BUILD_SESSION,
   // Policy / ACL (workhorse)
   check_permission: CHECK_PERMISSION,
   filter_by_permission: FILTER_BY_PERMISSION,
@@ -8253,6 +9533,8 @@ var MCP_TOOL_CONTRACTS = {
   get_topic: GET_TOPIC,
   update_topic: UPDATE_TOPIC,
   get_topic_tree: GET_TOPIC_TREE,
+  materialize_topic_graph: MATERIALIZE_TOPIC_GRAPH,
+  get_topic_graph_spine: GET_TOPIC_GRAPH_SPINE,
   // Coding intelligence (code-grounded knowledge)
   get_code_context: GET_CODE_CONTEXT,
   get_change_history: GET_CHANGE_HISTORY,
@@ -8357,18 +9639,34 @@ var MCP_CORE_OPERATION_NAMES = [
   "find_missing_questions",
   "get_high_priority_questions",
   "get_falsification_questions",
+  "create_epistemic_node",
+  "get_epistemic_node",
+  "list_epistemic_nodes",
+  "update_epistemic_node",
+  "archive_epistemic_node",
+  "verify_epistemic_node",
+  "supersede_epistemic_node",
+  "batch_create_epistemic_nodes",
   "create_topic",
   "get_topic",
   "list_topics",
   "update_topic",
-  "get_topic_tree"
+  "get_topic_tree",
+  "materialize_topic_graph",
+  "get_topic_graph_spine"
 ];
 var MCP_ANALYSIS_PLATFORM_OPERATION_NAMES = [
   "create_edge",
+  "update_edge",
+  "remove_edge",
+  "remove_edges_between",
+  "batch_create_edges",
   "query_lineage",
   "traverse_graph",
   "get_graph_neighborhood",
   "get_graph_structure_analysis",
+  "list_graph_intelligence_queries",
+  "run_graph_intelligence_query",
   "find_contradictions",
   "flag_contradiction",
   "detect_confirmation_bias",
@@ -8447,6 +9745,7 @@ var PLATFORM_INTERNAL_OPERATION_NAMES = [
   "get_change_history",
   "get_failure_log",
   "record_attempt",
+  "begin_build_session",
   "push",
   "open_pull_request",
   "record_judgment",
@@ -8501,7 +9800,6 @@ var SDK_ONLY_OPERATION_NAMES = [
   "find_semantic_orphans"
 ];
 var MCP_ONLY_INTERNAL_OPERATION_NAMES = [
-  "begin_build_session",
   "evaluate_engineering_contract",
   "evaluate_research_contract"
 ];
@@ -8756,9 +10054,7 @@ function mcpContractFromArgsSchema(base, args, contractName) {
     required: converted.filter(([, field]) => field.required).map(([fieldName]) => fieldName)
   };
 }
-function defineFunctionContract(contract) {
-  return contract;
-}
+var defineFunctionContract = (contract) => contract;
 function authUserId(context) {
   return context.userId ?? context.principalId ?? "lucern-agent";
 }
@@ -8887,8 +10183,34 @@ function assertSurfaceCoverage(contracts) {
     }
   }
 }
-
-// ../contracts/src/function-registry/context.ts
+var jsonRecordSchema2 = z.record(z.unknown());
+var observationArgs = z.object({
+  topicId: z.string().optional().describe("Topic scope for the observation."),
+  summary: z.string().describe("Short observation summary."),
+  text: z.string().optional().describe("Canonical observation text alias."),
+  title: z.string().optional().describe("Optional observation title."),
+  content: z.string().optional().describe("Optional rich observation content."),
+  contentType: z.string().optional().describe("Observation content type."),
+  kind: z.string().optional().describe("Evidence kind to store."),
+  observationType: z.string().optional().describe("Observation type."),
+  tags: z.array(z.string()).optional().describe("Observation tags."),
+  source: z.string().optional().describe("Observation source label."),
+  sourceType: z.string().optional().describe("Evidence source type."),
+  externalSourceType: z.string().optional().describe("External source type for imported observations."),
+  sourceUrl: z.string().optional().describe("Canonical source URL."),
+  confidence: z.number().optional().describe("Observation confidence."),
+  metadata: jsonRecordSchema2.optional().describe("Observation metadata."),
+  rationale: z.string().optional().describe("Why this observation should be recorded.")
+});
+var observationContextArgs = z.object({
+  topicId: z.string().describe("Topic scope."),
+  query: z.string().optional().describe("Optional context query."),
+  limit: z.number().optional().describe("Maximum observations to return."),
+  status: z.string().optional().describe("Observation status filter.")
+});
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 var observationInput = (input, context) => withUserId(
   compactRecord4({
     projectId: input.projectId,
@@ -8921,7 +10243,7 @@ var contextContracts = [
     path: "/context/compile",
     sdkNamespace: "context",
     sdkMethod: "compileContext",
-    summary: "Compile a focused reasoning context for a topic.",
+    summary: "Compile a focused reasoning context, resolving topic from query when omitted.",
     convex: {
       module: "contextCompiler",
       functionName: "compile",
@@ -8943,11 +10265,12 @@ var contextContracts = [
       kind: "mutation",
       inputProjection: observationInput,
       outputProjection: (output, input) => ({
-        ...output && typeof output === "object" ? output : {},
-        observationId: output && typeof output === "object" ? output.nodeId : void 0,
+        ...isRecord2(output) ? output : {},
+        observationId: isRecord2(output) ? output.nodeId : void 0,
         observationType: input.observationType
       })
-    }
+    },
+    args: observationArgs
   }),
   surfaceContract({
     name: "get_observation_context",
@@ -8968,7 +10291,8 @@ var contextContracts = [
         status: input.status,
         userId: input.userId
       })
-    }
+    },
+    args: observationContextArgs
   })
 ];
 
@@ -9031,8 +10355,45 @@ var identityContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/beliefs.ts
+var jsonRecordSchema3 = z.record(z.unknown());
+var sourceTypeSchema = z.enum(["human", "ai_extracted", "ai_generated"]);
+var reversibilitySchema = z.enum([
+  "irreversible",
+  "hard_to_reverse",
+  "reversible",
+  "trivial"
+]);
+var predictionMetaSchema = z.object({
+  isPrediction: z.boolean().describe("Whether this belief is a prediction."),
+  registeredAt: z.number().describe("Timestamp when the prediction was registered."),
+  expectedBy: z.number().optional().describe("Timestamp when the prediction should be evaluated.")
+});
+var createBeliefArgs = z.object({
+  canonicalText: z.string().describe("The belief statement the agent holds to be true."),
+  topicId: z.string().optional().describe("Topic scope hint for the belief."),
+  baseRate: z.number().optional().describe("Prior base rate used to seed the vacuous opinion."),
+  beliefType: z.string().optional().describe("Schema belief type."),
+  metadata: jsonRecordSchema3.optional().describe("Extra metadata merged into the belief node."),
+  rationale: z.string().optional().describe("Why this belief should enter the reasoning graph."),
+  pillar: z.string().optional().describe("Innovation pillar or product pillar associated with the belief."),
+  worktreeId: z.string().optional().describe("Worktree responsible for creating or testing this belief."),
+  sourceBeliefIds: z.array(z.string()).optional().describe("Source belief IDs this belief derives from."),
+  sourceType: sourceTypeSchema.optional().describe("Actor/source class that produced the belief."),
+  reversibility: reversibilitySchema.optional().describe("How reversible the belief's implied decision is."),
+  predictionMeta: predictionMetaSchema.optional().describe("Prediction lifecycle metadata when this belief is a forecast.")
+});
+var forkBeliefArgs = z.object({
+  nodeId: z.string().describe("The scored belief to fork from."),
+  newFormulation: z.string().describe("The evolved belief statement."),
+  forkReason: z.enum([
+    "refinement",
+    "contradiction_response",
+    "scope_change",
+    "confidence_collapse",
+    "manual"
+  ]).describe("Why this fork was created."),
+  rationale: z.string().optional().describe("Why the fork is warranted.")
+});
 var beliefLookupInput = (input) => compactRecord4({
   nodeId: input.nodeId ?? input.id ?? input.beliefId,
   beliefId: input.beliefId
@@ -9107,7 +10468,8 @@ var beliefsContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: createBeliefInput
-    }
+    },
+    args: createBeliefArgs
   }),
   surfaceContract({
     name: "get_belief",
@@ -9198,7 +10560,8 @@ var beliefsContracts = [
       functionName: "forkBelief",
       kind: "mutation",
       inputProjection: forkBeliefInput
-    }
+    },
+    args: forkBeliefArgs
   }),
   surfaceContract({
     name: "archive_belief",
@@ -9279,8 +10642,46 @@ var beliefsContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/evidence.ts
+var jsonRecordSchema4 = z.record(z.unknown());
+var evidenceRelationSchema = z.enum(["supports", "contradicts", "neutral"]);
+var createEvidenceArgs = z.object({
+  topicId: z.string().optional().describe("Topic scope for the evidence."),
+  text: z.string().describe("Canonical evidence text."),
+  source: z.string().optional().describe("Source URL or source label."),
+  sourceUrl: z.string().optional().describe("Canonical source URL."),
+  targetId: z.string().optional().describe("Belief or question identifier to link immediately."),
+  linkedBeliefNodeId: z.string().optional().describe("Belief node this evidence bears on."),
+  evidenceRelation: evidenceRelationSchema.optional().describe("How the evidence relates to the linked belief."),
+  confidence: z.number().optional().describe("Confidence in the evidence relation."),
+  weight: z.number().optional().describe("Support weight from -1.0 to +1.0."),
+  metadata: jsonRecordSchema4.optional().describe("Metadata merged into the canonical evidence node."),
+  rationale: z.string().describe("Why this evidence should enter the reasoning graph."),
+  reasoning: z.string().optional().describe("Reasoning note preserved in evidence metadata."),
+  title: z.string().optional().describe("Optional short title."),
+  content: z.string().optional().describe("Optional long-form content."),
+  contentType: z.string().optional().describe("Content format or MIME hint."),
+  kind: z.string().optional().describe("Evidence kind."),
+  tags: z.array(z.string()).optional().describe("Evidence tags."),
+  sourceType: z.string().optional().describe("Evidence source type."),
+  externalSourceType: z.string().optional().describe("External source type for imported evidence."),
+  sourceQuestionId: z.string().optional().describe("Question that sourced this evidence."),
+  methodology: z.string().optional().describe("Collection methodology."),
+  informationAsymmetry: z.string().optional().describe("Information asymmetry class."),
+  sourceDescription: z.string().optional().describe("Human-readable source description.")
+});
+var addEvidenceArgs = z.object({
+  canonicalText: z.string().describe("The evidence statement."),
+  text: z.string().optional().describe("Canonical evidence text alias used by newer callers."),
+  topicId: z.string().optional().describe("Topic scope hint."),
+  sourceUrl: z.string().optional().describe("URL of the source material."),
+  targetNodeId: z.string().describe("The belief this evidence bears on."),
+  weight: z.number().optional().describe("Support weight from -1.0 to +1.0."),
+  reasoning: z.string().describe("Why this evidence is relevant to the target belief."),
+  title: z.string().optional().describe("Optional short title."),
+  content: z.string().optional().describe("Optional long-form evidence content."),
+  contentType: z.string().optional().describe("Content format or MIME hint."),
+  metadata: jsonRecordSchema4.optional().describe("Optional metadata merged into the evidence node.")
+});
 var evidenceIdInput = (input) => compactRecord4({
   evidenceId: input.evidenceId,
   insightId: input.insightId,
@@ -9308,12 +10709,12 @@ var linkEvidenceToBeliefEdgeInput = (input, context) => withCreatedBy(
   compactRecord4({
     fromNodeId: input.insightId ?? input.evidenceNodeId ?? input.evidenceId,
     toNodeId: input.beliefNodeId ?? input.beliefId ?? input.targetId,
-    edgeType: "evidence_supports_belief",
+    edgeType: "informs",
     globalId: input.globalId ?? `edge:${String(
       input.insightId ?? input.evidenceNodeId ?? input.evidenceId
     )}:${String(
       input.beliefNodeId ?? input.beliefId ?? input.targetId
-    )}:evidence_supports_belief`,
+    )}:informs`,
     weight: typeof input.weight === "number" ? input.weight : input.type === "contradicting" ? -1 : 1,
     context: input.rationale ?? input.context,
     skipLayerValidation: true,
@@ -9326,12 +10727,12 @@ var linkEvidenceToQuestionEdgeInput = (input, context) => withCreatedBy(
   compactRecord4({
     fromNodeId: input.insightId ?? input.evidenceNodeId ?? input.evidenceId,
     toNodeId: input.questionId ?? input.questionNodeId ?? input.targetId,
-    edgeType: "evidence_supports_question",
+    edgeType: "responds_to",
     globalId: input.globalId ?? `edge:${String(
       input.insightId ?? input.evidenceNodeId ?? input.evidenceId
     )}:${String(
       input.questionId ?? input.questionNodeId ?? input.targetId
-    )}:evidence_supports_question`,
+    )}:responds_to`,
     weight: input.impactScore ?? input.weight,
     context: input.rationale ?? input.context,
     skipLayerValidation: true,
@@ -9355,7 +10756,8 @@ var evidenceContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: createEvidenceInput
-    }
+    },
+    args: createEvidenceArgs
   }),
   surfaceContract({
     name: "add_evidence",
@@ -9391,7 +10793,8 @@ var evidenceContracts = [
           context
         );
       }
-    }
+    },
+    args: addEvidenceArgs
   }),
   surfaceContract({
     name: "get_evidence",
@@ -9498,8 +10901,91 @@ var evidenceContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/questions.ts
+var jsonRecordSchema5 = z.record(z.unknown());
+var questionPrioritySchema = z.enum(["urgent", "high", "medium", "low"]);
+var kernelQuestionPrioritySchema = z.enum([
+  "critical",
+  "high",
+  "medium",
+  "low"
+]);
+var questionTypeSchema = z.enum([
+  "validation",
+  "falsification",
+  "assumption_probe",
+  "prediction_test",
+  "counterfactual",
+  "discovery",
+  "clarification",
+  "comparison",
+  "causal",
+  "mechanism",
+  "general"
+]);
+var createQuestionArgs = z.object({
+  text: z.string().describe("The question text."),
+  question: z.string().optional().describe("Backend question text alias for kernel-native callers."),
+  topicId: z.string().optional().describe("Topic scope hint."),
+  priority: questionPrioritySchema.optional().describe("Human-facing question priority."),
+  linkedBeliefId: z.string().optional().describe("Belief this question tests."),
+  linkedBeliefNodeId: z.string().optional().describe("Belief node this question tests."),
+  metadata: jsonRecordSchema5.optional().describe("Optional metadata merged into the question record."),
+  category: z.string().optional().describe("Question category."),
+  source: z.string().optional().describe("Question source."),
+  testType: z.enum(["validates", "invalidates", "clarifies"]).optional().describe("How this question tests its linked belief."),
+  importance: z.number().optional().describe("Numeric importance score."),
+  epistemicUnlock: z.string().optional().describe("What this question unlocks if answered."),
+  sourceQuestionIds: z.array(z.string()).optional().describe("Question IDs this question derives from."),
+  linkedWorktreeId: z.string().optional().describe("Worktree this question belongs to."),
+  questionType: questionTypeSchema.optional().describe("Question type."),
+  questionPriority: kernelQuestionPrioritySchema.optional().describe("Kernel-native question priority.")
+});
+var refineQuestionArgs = z.object({
+  id: z.string().describe("The question to refine."),
+  text: z.string().describe("Updated question text."),
+  question: z.string().optional().describe("Backend question text alias for kernel-native callers."),
+  rationale: z.string().optional().describe("Why the question is refined."),
+  category: z.string().optional().describe("Updated question category."),
+  priority: questionPrioritySchema.optional().describe("Updated human-facing priority.")
+});
+var createAnswerArgs = z.object({
+  questionNodeId: z.string().describe("The question node ID this answer responds to."),
+  questionId: z.string().optional().describe("Question ID alias accepted by the projection."),
+  answerText: z.string().describe("The answer content."),
+  topicId: z.string().optional().describe("Topic scope for the answer."),
+  confidence: z.string().optional().describe("Answer confidence."),
+  evidenceNodeIds: z.array(z.string()).optional().describe("Evidence node IDs supporting the answer."),
+  answerSource: z.string().optional().describe("How the answer was produced."),
+  worktreeId: z.string().optional().describe("Worktree whose outcome produced this answer."),
+  sprintId: z.string().optional().describe("Legacy sprint identifier.")
+});
+var answerQuestionArgs = z.object({
+  id: z.string().describe("Canonical question ID."),
+  topicId: z.string().describe("Topic scope for the answer."),
+  text: z.string().describe("Answer text."),
+  confidence: z.enum(["weak", "medium", "strong"]).optional().describe("Optional answer confidence."),
+  evidenceIds: z.array(z.string()).optional().describe("Canonical evidence IDs supporting the answer."),
+  rationale: z.string().optional().describe("Why this answer is credible."),
+  questionId: z.string().optional().describe("Question ID alias accepted by the projection."),
+  questionNodeId: z.string().optional().describe("Question node ID alias accepted by the projection."),
+  answerText: z.string().optional().describe("Canonical answer text alias accepted by newer callers."),
+  evidenceNodeIds: z.array(z.string()).optional().describe("Evidence node ID alias accepted by newer callers."),
+  answerSource: z.string().optional().describe("How the answer was produced."),
+  worktreeId: z.string().optional().describe("Worktree whose outcome produced this answer."),
+  sprintId: z.string().optional().describe("Legacy sprint identifier.")
+});
+var missingQuestionsArgs = z.object({
+  topicId: z.string().describe("Topic scope."),
+  minConfidence: z.number().optional().describe("Minimum confidence threshold for missing-question checks."),
+  status: z.string().optional().describe("Question status filter."),
+  limit: z.number().optional().describe("Maximum questions to inspect.")
+});
+var falsificationQuestionsArgs = z.object({
+  topicId: z.string().describe("Topic scope."),
+  beliefIds: z.array(z.string()).optional().describe("Beliefs to generate falsification questions for."),
+  status: z.string().optional().describe("Question status filter."),
+  limit: z.number().optional().describe("Maximum questions to inspect.")
+});
 var questionNodeInput = (input) => compactRecord4({
   nodeId: input.nodeId ?? input.id ?? input.questionId,
   questionId: input.questionId
@@ -9546,7 +11032,8 @@ var questionsContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: createQuestionInput
-    }
+    },
+    args: createQuestionArgs
   }),
   surfaceContract({
     name: "get_question",
@@ -9602,7 +11089,8 @@ var questionsContracts = [
         category: input.category,
         priority: input.priority
       })
-    }
+    },
+    args: refineQuestionArgs
   }),
   surfaceContract({
     name: "update_question_status",
@@ -9678,7 +11166,8 @@ var questionsContracts = [
         }),
         context
       )
-    }
+    },
+    args: createAnswerArgs
   }),
   surfaceContract({
     name: "answer_question",
@@ -9707,7 +11196,8 @@ var questionsContracts = [
         }),
         context
       )
-    }
+    },
+    args: answerQuestionArgs
   }),
   surfaceContract({
     name: "get_answer",
@@ -9739,7 +11229,8 @@ var questionsContracts = [
       functionName: "getByTopic",
       kind: "query",
       inputProjection: questionTopicInput
-    }
+    },
+    args: missingQuestionsArgs
   }),
   surfaceContract({
     name: "get_high_priority_questions",
@@ -9774,11 +11265,54 @@ var questionsContracts = [
       functionName: "getByTopic",
       kind: "query",
       inputProjection: questionTopicInput
-    }
+    },
+    args: falsificationQuestionsArgs
   })
 ];
-
-// ../contracts/src/function-registry/topics.ts
+var topicVisibilitySchema = z.enum([
+  "private",
+  "team",
+  "firm",
+  "external",
+  "public"
+]);
+var topicStatusSchema = z.enum(["active", "archived", "watching"]);
+var createTopicArgs = z.object({
+  globalId: z.string().optional().describe("Optional idempotent topic global ID."),
+  name: z.string().describe("Topic name."),
+  description: z.string().optional().describe("Topic description."),
+  type: z.string().describe("Topic type."),
+  parentTopicId: z.string().optional().describe("Optional parent topic ID."),
+  parentTopicGlobalId: z.string().optional().describe("Optional parent topic global ID."),
+  ontologyId: z.string().optional().describe("Ontology to bind."),
+  tenantId: z.string().optional().describe("Optional tenant scope."),
+  workspaceId: z.string().optional().describe("Optional workspace scope."),
+  visibility: topicVisibilitySchema.optional().describe("Topic visibility."),
+  metadata: z.record(z.unknown()).optional().describe("Topic metadata."),
+  graphScopeProjectId: z.string().optional(),
+  createdBy: z.string().optional()
+});
+var updateTopicArgs = z.object({
+  id: z.string().describe("Topic ID."),
+  topicId: z.string().optional().describe("Topic ID alias."),
+  name: z.string().optional().describe("Topic name."),
+  description: z.string().optional().describe("Topic description."),
+  type: z.string().optional().describe("Topic type."),
+  status: topicStatusSchema.optional().describe("Topic status."),
+  visibility: topicVisibilitySchema.optional().describe("Topic visibility."),
+  ontologyId: z.string().optional().describe("Ontology to bind."),
+  clearOntologyId: z.boolean().optional().describe("Whether to clear the ontology binding."),
+  metadata: z.record(z.unknown()).optional().describe("Topic metadata.")
+});
+var materializeTopicGraphArgs = z.object({
+  rootTopicId: z.string().optional().describe("Optional root topic ID."),
+  dryRun: z.boolean().optional().describe("Report missing rows without writing."),
+  createdBy: z.string().optional()
+});
+var getTopicGraphSpineArgs = z.object({
+  rootTopicId: z.string().optional().describe("Optional root topic ID."),
+  includeTopicBeliefEdges: z.boolean().optional()
+});
 var topicIdInput = (input) => compactRecord4({
   id: input.id ?? input.topicId
 });
@@ -9809,7 +11343,8 @@ var topicsContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: withCreatedBy
-    }
+    },
+    args: createTopicArgs
   }),
   surfaceContract({
     name: "get_topic",
@@ -9859,7 +11394,8 @@ var topicsContracts = [
       functionName: "update",
       kind: "mutation",
       inputProjection: updateTopicInput
-    }
+    },
+    args: updateTopicArgs
   }),
   surfaceContract({
     name: "get_topic_tree",
@@ -9876,85 +11412,505 @@ var topicsContracts = [
       functionName: "getTree",
       kind: "query"
     }
+  }),
+  surfaceContract({
+    name: "materialize_topic_graph",
+    kind: "mutation",
+    domain: "topics",
+    surfaceClass: "platform_public",
+    path: "/topics/materialize-graph",
+    sdkNamespace: "topics",
+    sdkMethod: "materializeTopicGraph",
+    summary: "Materialize topic nodes and parent-child graph edges.",
+    convex: {
+      module: "topics",
+      functionName: "materializeTopicGraph",
+      kind: "mutation",
+      inputProjection: withCreatedBy
+    },
+    args: materializeTopicGraphArgs
+  }),
+  surfaceContract({
+    name: "get_topic_graph_spine",
+    kind: "query",
+    domain: "topics",
+    surfaceClass: "platform_public",
+    method: "GET",
+    path: "/topics/graph-spine",
+    sdkNamespace: "topics",
+    sdkMethod: "getTopicGraphSpine",
+    summary: "Verify topic nodes and parent-child graph edges.",
+    convex: {
+      module: "topics",
+      functionName: "getTopicGraphSpine",
+      kind: "query"
+    },
+    args: getTopicGraphSpineArgs
   })
 ];
-
-// ../contracts/src/function-registry/lenses.ts
-var createLensInput = (input, context) => compactRecord4({
-  name: input.name,
-  description: input.description,
-  workspaceId: input.workspaceId,
-  topicId: input.topicId,
-  perspectiveType: input.perspectiveType,
-  promptTemplates: input.promptTemplates,
-  workflowTemplates: input.workflowTemplates,
-  taskTemplates: input.taskTemplates,
-  questionTemplates: input.questionTemplates,
-  filterCriteria: input.filterCriteria,
-  metadata: input.metadata,
-  createdBy: authUserId(context)
+var sourceTypeSchema2 = z.enum([
+  "human",
+  "ai_extracted",
+  "ai_generated",
+  "imported",
+  "system",
+  "verified",
+  "proprietary"
+]);
+var verificationStatusSchema = z.enum([
+  "unverified",
+  "human_verified",
+  "ai_verified",
+  "contradicted",
+  "outdated"
+]);
+var nodeStatusSchema = z.enum([
+  "active",
+  "superseded",
+  "archived",
+  "deleted"
+]);
+var externalIdsArgs = z.object({
+  crunchbase: z.string().optional(),
+  linkedin: z.string().optional(),
+  pitchbook: z.string().optional(),
+  twitter: z.string().optional(),
+  website: z.string().optional()
+}).optional();
+var createEpistemicNodeItemArgs = z.object({
+  globalId: z.string().optional().describe("Optional idempotent node global ID."),
+  nodeType: NODE_TYPE.describe("Public epistemic node type."),
+  subtype: z.string().optional(),
+  canonicalText: z.string().optional().describe("Canonical node text."),
+  text: z.string().optional().describe("Alias for canonicalText."),
+  contentHash: z.string().optional().describe("Optional idempotency content hash."),
+  content: z.string().optional(),
+  contentType: z.string().optional(),
+  title: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  domain: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
+  externalIds: externalIdsArgs,
+  sourceType: sourceTypeSchema2.optional(),
+  aiProvider: z.string().optional(),
+  extractedFromNodeId: z.string().optional(),
+  confidence: z.number().optional(),
+  verificationStatus: verificationStatusSchema.optional(),
+  topicId: z.string().optional(),
+  projectId: z.string().optional(),
+  createdBy: z.string().optional(),
+  trustedBypassAccessCheck: z.boolean().optional()
 });
-var lensListInput = (input, context) => compactRecord4({
-  actorId: input.actorId ?? authUserId(context),
-  workspaceId: input.workspaceId,
+var createEpistemicNodeArgs = createEpistemicNodeItemArgs;
+var batchCreateEpistemicNodesArgs = z.object({
+  nodes: z.array(createEpistemicNodeItemArgs)
+});
+var getEpistemicNodeArgs = z.object({
+  nodeId: z.string().describe("Node ID or global ID."),
+  globalId: z.string().optional().describe("Node global ID alias.")
+});
+var listEpistemicNodesArgs = z.object({
+  topicId: z.string().optional(),
+  projectId: z.string().optional(),
+  nodeType: NODE_TYPE.optional(),
+  status: nodeStatusSchema.optional(),
+  searchQuery: z.string().optional(),
+  query: z.string().optional(),
+  limit: z.number().optional()
+});
+var updateEpistemicNodeArgs = z.object({
+  nodeId: z.string().describe("Node ID or global ID."),
+  id: z.string().optional().describe("Node ID alias."),
+  subtype: z.string().optional(),
+  canonicalText: z.string().optional(),
+  text: z.string().optional(),
+  contentHash: z.string().optional(),
+  content: z.string().optional(),
+  contentType: z.string().optional(),
+  title: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  domain: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
+  externalIds: externalIdsArgs,
+  confidence: z.number().optional(),
+  verificationStatus: verificationStatusSchema.optional(),
+  status: nodeStatusSchema.optional(),
+  userId: z.string().optional(),
+  trustedBypassAccessCheck: z.boolean().optional()
+});
+var archiveEpistemicNodeArgs = z.object({
+  nodeId: z.string().describe("Node ID or global ID."),
+  id: z.string().optional().describe("Node ID alias."),
+  userId: z.string().optional(),
+  trustedBypassAccessCheck: z.boolean().optional()
+});
+var verifyEpistemicNodeArgs = z.object({
+  nodeId: z.string().describe("Node ID or global ID."),
+  id: z.string().optional().describe("Node ID alias."),
+  verificationStatus: verificationStatusSchema,
+  confidence: z.number().optional(),
+  userId: z.string().optional()
+});
+var supersedeEpistemicNodeArgs = z.object({
+  oldNodeId: z.string().describe("Node ID or global ID to supersede."),
+  nodeId: z.string().optional().describe("Old node ID alias."),
+  newGlobalId: z.string().optional(),
+  newCanonicalText: z.string().optional(),
+  text: z.string().optional(),
+  canonicalText: z.string().optional(),
+  newContentHash: z.string().optional(),
+  reason: z.string().optional(),
+  createdBy: z.string().optional(),
+  trustedBypassAccessCheck: z.boolean().optional()
+});
+function generatedGlobalId(prefix) {
+  return `${prefix}:${crypto.randomUUID()}`;
+}
+function resolveCanonicalText(input) {
+  const text = input.canonicalText ?? input.text ?? input.title ?? input.content;
+  if (typeof text !== "string" || text.trim().length === 0) {
+    throw new Error("canonicalText or text is required.");
+  }
+  return text;
+}
+function createNodeInput(input, context) {
+  const canonicalText = resolveCanonicalText(input);
+  const nodeType = String(input.nodeType);
+  return withCreatedBy(
+    compactRecord4({
+      globalId: typeof input.globalId === "string" && input.globalId.trim() ? input.globalId : generatedGlobalId(nodeType),
+      nodeType,
+      subtype: input.subtype,
+      canonicalText,
+      contentHash: typeof input.contentHash === "string" && input.contentHash.trim() ? input.contentHash : `${nodeType}:${canonicalText}`,
+      content: input.content,
+      contentType: input.contentType,
+      title: input.title,
+      tags: input.tags,
+      domain: input.domain,
+      metadata: input.metadata,
+      externalIds: input.externalIds,
+      sourceType: typeof input.sourceType === "string" && input.sourceType.trim() ? input.sourceType : "human",
+      aiProvider: input.aiProvider,
+      extractedFromNodeId: input.extractedFromNodeId,
+      confidence: input.confidence,
+      verificationStatus: input.verificationStatus,
+      topicId: input.topicId,
+      projectId: input.projectId
+    }),
+    context
+  );
+}
+var getNodeInput = (input) => compactRecord4({
+  nodeId: input.nodeId ?? input.globalId
+});
+var listNodesInput = (input) => compactRecord4({
   topicId: input.topicId,
+  projectId: input.projectId,
+  nodeType: input.nodeType,
   status: input.status,
-  perspectiveType: input.perspectiveType
+  searchQuery: input.searchQuery ?? input.query,
+  limit: input.limit
 });
-var lensesContracts = [
+var updateNodeInput = (input, context) => withUserId(
+  compactRecord4({
+    nodeId: input.nodeId ?? input.id,
+    subtype: input.subtype,
+    canonicalText: input.canonicalText ?? input.text,
+    contentHash: input.contentHash,
+    content: input.content,
+    contentType: input.contentType,
+    title: input.title,
+    tags: input.tags,
+    domain: input.domain,
+    metadata: input.metadata,
+    externalIds: input.externalIds,
+    confidence: input.confidence,
+    verificationStatus: input.verificationStatus,
+    status: input.status,
+    trustedBypassAccessCheck: input.trustedBypassAccessCheck
+  }),
+  context
+);
+var archiveNodeInput = (input, context) => withUserId(
+  compactRecord4({
+    nodeId: input.nodeId ?? input.id,
+    trustedBypassAccessCheck: input.trustedBypassAccessCheck
+  }),
+  context
+);
+var verifyNodeInput = (input, context) => withUserId(
+  compactRecord4({
+    nodeId: input.nodeId ?? input.id,
+    verificationStatus: input.verificationStatus,
+    confidence: input.confidence
+  }),
+  context
+);
+var supersedeNodeInput = (input, context) => {
+  const newCanonicalText = input.newCanonicalText ?? input.canonicalText ?? input.text;
+  if (typeof newCanonicalText !== "string" || newCanonicalText.trim().length === 0) {
+    throw new Error("newCanonicalText or text is required.");
+  }
+  return {
+    oldNodeId: input.oldNodeId ?? input.nodeId,
+    newGlobalId: typeof input.newGlobalId === "string" && input.newGlobalId.trim() ? input.newGlobalId : generatedGlobalId("node"),
+    newCanonicalText,
+    newContentHash: typeof input.newContentHash === "string" && input.newContentHash.trim() ? input.newContentHash : `superseded:${newCanonicalText}`,
+    createdBy: typeof input.createdBy === "string" ? input.createdBy : authUserId(context),
+    reason: input.reason,
+    trustedBypassAccessCheck: input.trustedBypassAccessCheck
+  };
+};
+var batchCreateNodesInput = (input, context) => {
+  const nodes = Array.isArray(input.nodes) ? input.nodes : [];
+  return {
+    nodes: nodes.map(
+      (node) => createNodeInput(
+        node && typeof node === "object" ? node : {},
+        context
+      )
+    )
+  };
+};
+var nodesContracts = [
   surfaceContract({
-    name: "create_lens",
+    name: "create_epistemic_node",
     kind: "mutation",
-    domain: "lenses",
+    domain: "nodes",
     surfaceClass: "platform_public",
-    path: "/lenses",
-    sdkNamespace: "lenses",
-    sdkMethod: "createLens",
-    summary: "Create a lens.",
+    path: "/nodes",
+    sdkNamespace: "nodes",
+    sdkMethod: "createEpistemicNode",
+    summary: "Create a generic epistemic graph node.",
     convex: {
-      module: "lenses",
+      module: "nodes",
       functionName: "create",
       kind: "mutation",
-      inputProjection: createLensInput
-    }
+      inputProjection: createNodeInput
+    },
+    args: createEpistemicNodeArgs
   }),
   surfaceContract({
-    name: "list_lenses",
+    name: "get_epistemic_node",
     kind: "query",
-    domain: "lenses",
+    domain: "nodes",
     surfaceClass: "platform_public",
     method: "GET",
-    path: "/lenses",
-    sdkNamespace: "lenses",
-    sdkMethod: "listLenses",
-    summary: "List lenses.",
+    path: "/nodes/get",
+    sdkNamespace: "nodes",
+    sdkMethod: "getEpistemicNode",
+    summary: "Get a generic epistemic graph node.",
     convex: {
-      module: "lenses",
+      module: "nodes",
+      functionName: "get",
+      kind: "query",
+      inputProjection: getNodeInput
+    },
+    args: getEpistemicNodeArgs
+  }),
+  surfaceContract({
+    name: "list_epistemic_nodes",
+    kind: "query",
+    domain: "nodes",
+    surfaceClass: "platform_public",
+    method: "GET",
+    path: "/nodes",
+    sdkNamespace: "nodes",
+    sdkMethod: "listEpistemicNodes",
+    summary: "List generic epistemic graph nodes.",
+    convex: {
+      module: "nodes",
       functionName: "list",
       kind: "query",
-      inputProjection: lensListInput
-    }
+      inputProjection: listNodesInput
+    },
+    args: listEpistemicNodesArgs
   }),
   surfaceContract({
-    name: "apply_lens_to_topic",
+    name: "update_epistemic_node",
     kind: "mutation",
-    domain: "lenses",
+    domain: "nodes",
     surfaceClass: "platform_public",
-    path: "/lenses/apply",
-    sdkNamespace: "lenses",
-    sdkMethod: "applyLensToTopic",
-    summary: "Apply a lens to a topic.",
+    method: "PATCH",
+    path: "/nodes",
+    sdkNamespace: "nodes",
+    sdkMethod: "updateEpistemicNode",
+    summary: "Update a generic epistemic graph node.",
     convex: {
-      module: "lenses",
-      functionName: "applyToTopic",
+      module: "nodes",
+      functionName: "update",
       kind: "mutation",
-      inputProjection: (input, context) => compactRecord4({
-        lensId: input.lensId,
-        topicId: input.topicId,
-        metadata: input.metadata,
-        appliedBy: authUserId(context)
-      })
-    }
+      inputProjection: updateNodeInput
+    },
+    args: updateEpistemicNodeArgs
+  }),
+  surfaceContract({
+    name: "archive_epistemic_node",
+    kind: "mutation",
+    domain: "nodes",
+    surfaceClass: "platform_public",
+    path: "/nodes/archive",
+    sdkNamespace: "nodes",
+    sdkMethod: "archiveEpistemicNode",
+    summary: "Archive a generic epistemic graph node.",
+    convex: {
+      module: "nodes",
+      functionName: "archive",
+      kind: "mutation",
+      inputProjection: archiveNodeInput
+    },
+    args: archiveEpistemicNodeArgs
+  }),
+  surfaceContract({
+    name: "verify_epistemic_node",
+    kind: "mutation",
+    domain: "nodes",
+    surfaceClass: "platform_public",
+    path: "/nodes/verify",
+    sdkNamespace: "nodes",
+    sdkMethod: "verifyEpistemicNode",
+    summary: "Verify a generic epistemic graph node.",
+    convex: {
+      module: "nodes",
+      functionName: "verify",
+      kind: "mutation",
+      inputProjection: verifyNodeInput
+    },
+    args: verifyEpistemicNodeArgs
+  }),
+  surfaceContract({
+    name: "supersede_epistemic_node",
+    kind: "mutation",
+    domain: "nodes",
+    surfaceClass: "platform_public",
+    path: "/nodes/supersede",
+    sdkNamespace: "nodes",
+    sdkMethod: "supersedeEpistemicNode",
+    summary: "Supersede a generic epistemic graph node.",
+    convex: {
+      module: "nodes",
+      functionName: "supersede",
+      kind: "mutation",
+      inputProjection: supersedeNodeInput
+    },
+    args: supersedeEpistemicNodeArgs
+  }),
+  surfaceContract({
+    name: "batch_create_epistemic_nodes",
+    kind: "mutation",
+    domain: "nodes",
+    surfaceClass: "platform_public",
+    path: "/nodes/batch",
+    sdkNamespace: "nodes",
+    sdkMethod: "batchCreateEpistemicNodes",
+    summary: "Batch create generic epistemic graph nodes.",
+    convex: {
+      module: "nodes",
+      functionName: "batchCreate",
+      kind: "mutation",
+      inputProjection: batchCreateNodesInput
+    },
+    args: batchCreateEpistemicNodesArgs
+  })
+];
+var lensPerspectiveSchema = z.enum([
+  "investigation",
+  "monitoring",
+  "analysis",
+  "comparison",
+  "taxonomy"
+]);
+var jsonRecordSchema6 = z.record(z.unknown());
+var createLensArgs = z.object({
+  name: z.string().describe("Lens name."),
+  workspaceId: z.string().optional().describe("Workspace scope for the lens."),
+  topicId: z.string().optional().describe("Originating topic scope."),
+  description: z.string().optional().describe("What this lens investigates or monitors."),
+  perspectiveType: lensPerspectiveSchema.describe("Perspective type."),
+  promptTemplates: z.array(jsonRecordSchema6).optional().describe("Prompt templates used through this lens."),
+  workflowTemplates: z.array(jsonRecordSchema6).optional().describe("Guided workflow templates."),
+  taskTemplates: z.array(jsonRecordSchema6).optional().describe("Default task templates."),
+  questionTemplates: z.array(jsonRecordSchema6).optional().describe("Default question templates."),
+  filterCriteria: jsonRecordSchema6.optional().describe("Belief/evidence filtering criteria."),
+  metadata: jsonRecordSchema6.optional().describe("Additional lens metadata.")
+});
+var createLensInput = (input, context) => compactRecord4({
+  name: input.name,
+  description: input.description,
+  workspaceId: input.workspaceId,
+  topicId: input.topicId,
+  perspectiveType: input.perspectiveType,
+  promptTemplates: input.promptTemplates,
+  workflowTemplates: input.workflowTemplates,
+  taskTemplates: input.taskTemplates,
+  questionTemplates: input.questionTemplates,
+  filterCriteria: input.filterCriteria,
+  metadata: input.metadata,
+  createdBy: authUserId(context)
+});
+var lensListInput = (input, context) => compactRecord4({
+  actorId: input.actorId ?? authUserId(context),
+  workspaceId: input.workspaceId,
+  topicId: input.topicId,
+  status: input.status,
+  perspectiveType: input.perspectiveType
+});
+var lensesContracts = [
+  surfaceContract({
+    name: "create_lens",
+    kind: "mutation",
+    domain: "lenses",
+    surfaceClass: "platform_public",
+    path: "/lenses",
+    sdkNamespace: "lenses",
+    sdkMethod: "createLens",
+    summary: "Create a lens.",
+    convex: {
+      module: "lenses",
+      functionName: "create",
+      kind: "mutation",
+      inputProjection: createLensInput
+    },
+    args: createLensArgs
+  }),
+  surfaceContract({
+    name: "list_lenses",
+    kind: "query",
+    domain: "lenses",
+    surfaceClass: "platform_public",
+    method: "GET",
+    path: "/lenses",
+    sdkNamespace: "lenses",
+    sdkMethod: "listLenses",
+    summary: "List lenses.",
+    convex: {
+      module: "lenses",
+      functionName: "list",
+      kind: "query",
+      inputProjection: lensListInput
+    }
+  }),
+  surfaceContract({
+    name: "apply_lens_to_topic",
+    kind: "mutation",
+    domain: "lenses",
+    surfaceClass: "platform_public",
+    path: "/lenses/apply",
+    sdkNamespace: "lenses",
+    sdkMethod: "applyLensToTopic",
+    summary: "Apply a lens to a topic.",
+    convex: {
+      module: "lenses",
+      functionName: "applyToTopic",
+      kind: "mutation",
+      inputProjection: (input, context) => compactRecord4({
+        lensId: input.lensId,
+        topicId: input.topicId,
+        metadata: input.metadata,
+        appliedBy: authUserId(context)
+      })
+    }
   }),
   surfaceContract({
     name: "remove_lens_from_topic",
@@ -9978,8 +11934,18 @@ var lensesContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/ontologies.ts
+var updateOntologyArgs = z.object({
+  id: z.string().describe("Ontology definition ID."),
+  ontologyId: z.string().optional().describe("Ontology ID alias."),
+  name: z.string().optional().describe("Ontology display name."),
+  description: z.string().optional().describe("Ontology description."),
+  status: z.string().optional().describe("Ontology lifecycle status.")
+});
+var ontologyVersionLifecycleArgs = z.object({
+  id: z.string().describe("Ontology version ID."),
+  versionId: z.string().optional().describe("Ontology version ID alias."),
+  ontologyId: z.string().optional().describe("Ontology definition ID.")
+});
 var ontologyIdInput = (input) => compactRecord4({
   id: input.id ?? input.ontologyId
 });
@@ -10058,11 +12024,11 @@ var ontologiesContracts = [
         id: input.id ?? input.ontologyId,
         name: input.name,
         description: input.description,
-        parentOntologyId: input.parentOntologyId,
         status: input.status,
         actorId: input.actorId
       })
-    }
+    },
+    args: updateOntologyArgs
   }),
   surfaceContract({
     name: "archive_ontology",
@@ -10145,7 +12111,8 @@ var ontologiesContracts = [
       functionName: "publishOntologyVersion",
       kind: "mutation",
       inputProjection: ontologyVersionIdInput
-    }
+    },
+    args: ontologyVersionLifecycleArgs
   }),
   surfaceContract({
     name: "deprecate_ontology_version",
@@ -10161,7 +12128,8 @@ var ontologiesContracts = [
       functionName: "deprecateOntologyVersion",
       kind: "mutation",
       inputProjection: ontologyVersionIdInput
-    }
+    },
+    args: ontologyVersionLifecycleArgs
   }),
   surfaceContract({
     name: "resolve_effective_ontology",
@@ -10180,8 +12148,81 @@ var ontologiesContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/worktrees.ts
+var autoFixPolicyInputSchema = z.object({
+  enabled: z.boolean().optional().describe("Whether automatic remediation is enabled."),
+  mode: z.string().optional().describe("Automation mode for worktree auto-fixes."),
+  maxAttempts: z.number().optional().describe("Maximum number of auto-fix attempts."),
+  reviewer: z.string().optional().describe("Reviewer responsible for auto-fix oversight."),
+  maxActionsPerRun: z.number().optional().describe("Maximum number of auto-fix actions per run."),
+  permittedMutationTiers: z.array(z.enum(["read_only", "low_risk_write", "high_risk_write"])).optional().describe("Mutation tiers the auto-fix worker may execute."),
+  requireAuditTrail: z.boolean().optional().describe("Whether auto-fix actions must write an audit trail."),
+  escalationGate: z.string().optional().describe("Gate to trigger when auto-fix policy requires escalation.")
+}).passthrough().describe("Policy for permitted automatic remediation inside the worktree.");
+var worktreeKeyQuestionInputSchema = z.object({
+  question: z.string().describe("Question the worktree must resolve."),
+  status: z.enum(["open", "answered", "forked"]).optional().describe("Current disposition of the key question."),
+  answer: z.string().optional().describe("Captured answer when the key question is resolved."),
+  answerConfidence: z.enum(["high", "medium", "low"]).optional().describe("Confidence in the captured answer."),
+  linkedQuestionId: z.string().optional().describe("Canonical question node linked to this key question.")
+}).passthrough().describe("Question contract embedded in the worktree plan.");
+var worktreeEvidenceSignalInputSchema = z.object({
+  signal: z.string().describe("Evidence signal the worktree should collect."),
+  collected: z.boolean().optional().describe("Whether the signal has already been collected."),
+  progress: z.string().optional().describe("Collection progress note for the signal."),
+  notes: z.string().optional().describe("Additional evidence collection notes.")
+}).passthrough().describe("Evidence signal embedded in the worktree plan.");
+var worktreeDecisionGateInputSchema = z.object({
+  goCriteria: z.array(z.string()).describe("Criteria that must hold for the worktree to proceed."),
+  noGoSignals: z.array(z.string()).describe("Signals that stop or redirect the worktree."),
+  verdict: z.enum(["go", "no_go", "pivot", "pending"]).optional().describe("Current decision verdict for the worktree gate."),
+  verdictRationale: z.string().optional().describe("Rationale supporting the current gate verdict."),
+  decidedAt: z.number().optional().describe("Timestamp when the gate verdict was decided."),
+  decidedBy: z.string().optional().describe("Actor that decided the gate verdict.")
+}).passthrough().describe("Decision gate contract for worktree activation or exit.");
+var addWorktreeArgs = z.object({
+  title: z.string().describe("Human-readable worktree name or objective."),
+  name: z.string().optional().describe("Storage-name alias for callers that already use backend naming."),
+  topicId: z.string().optional().describe("Optional primary topic scope hint for resolver validation."),
+  projectId: z.string().optional().describe("Legacy topicId alias/hint."),
+  topicHint: z.string().optional().describe("Natural-language topic hint for automatic topic resolution."),
+  branchId: z.string().optional().describe("Legacy branch identifier for compatibility with workflow callers."),
+  objective: z.string().optional().describe("Reasoning objective this worktree is intended to resolve."),
+  hypothesis: z.string().optional().describe("Testable claim this worktree investigates."),
+  rationale: z.string().optional().describe("Why this worktree exists and why it belongs in the campaign."),
+  worktreeType: z.string().optional().describe("Schema-enum worktree type used for kernel lifecycle behavior."),
+  gate: z.string().optional().describe("Exit gate for this worktree."),
+  startDate: z.number().optional().describe("Planned start timestamp in milliseconds since epoch."),
+  endDate: z.number().optional().describe("Planned end timestamp in milliseconds since epoch."),
+  durationWeeks: z.number().optional().describe("Planned duration in weeks."),
+  confidenceImpact: z.enum(["high", "medium", "low"]).optional().describe("Expected confidence impact if this worktree succeeds."),
+  beliefFocus: z.string().optional().describe("Natural-language focus spanning the target belief neighborhood."),
+  beliefIds: z.array(z.string()).optional().describe("Legacy alias for targetBeliefIds."),
+  beliefs: z.array(z.string()).optional().describe("Legacy alias for targetBeliefIds."),
+  targetBeliefIds: z.array(z.string()).optional().describe("Belief node IDs this worktree is expected to test or update."),
+  targetQuestionIds: z.array(z.string()).optional().describe("Question node IDs this worktree is expected to answer."),
+  keyQuestions: z.array(worktreeKeyQuestionInputSchema).optional().describe("Inline key questions captured as part of the worktree plan."),
+  evidenceSignals: z.array(worktreeEvidenceSignalInputSchema).optional().describe("Evidence signals the worktree needs to collect or validate."),
+  decisionGate: worktreeDecisionGateInputSchema.optional(),
+  goCriteria: z.array(z.string()).optional().describe("Shorthand go criteria used to build decisionGate."),
+  noGoSignals: z.array(z.string()).optional().describe("Shorthand no-go signals used to build decisionGate."),
+  proofArtifacts: z.array(z.unknown()).optional().describe("Expected proof artifacts required to close the worktree."),
+  autoShape: z.boolean().optional().describe("Whether to invoke inquiry auto-shaping during creation."),
+  autoFixPolicy: autoFixPolicyInputSchema.optional(),
+  domainPackId: z.string().optional().describe("Domain pack whose shaping hooks should influence the worktree."),
+  tags: z.array(z.string()).optional().describe("Additional topic-resolution tags for the worktree."),
+  touchedPaths: z.array(z.string()).optional().describe("File paths used as topic-resolution signals."),
+  sourceRef: z.string().optional().describe("Source reference used as a topic-resolution signal."),
+  sourceKind: z.string().optional().describe("Source kind used as a topic-resolution signal."),
+  campaign: z.number().optional().describe("Top-level pipeline campaign number."),
+  lane: z.string().optional().describe("Campaign lane for the worktree."),
+  laneOrderInCampaign: z.number().optional().describe("Ordering for this lane within its campaign."),
+  orderInLane: z.number().optional().describe("Position of this worktree inside its lane."),
+  dependsOn: z.array(z.string()).optional().describe("Worktree IDs that must complete before this worktree."),
+  blocks: z.array(z.string()).optional().describe("Worktree IDs blocked by this worktree."),
+  staffingHint: z.string().optional().describe("Suggested staffing or agent allocation note."),
+  lensId: z.string().optional().describe("Lens that scopes this worktree when applicable."),
+  lastReconciledAt: z.number().optional().describe("Timestamp when worktree metadata was last reconciled.")
+});
 var worktreeIdInput = (input) => compactRecord4({
   worktreeId: input.worktreeId ?? input.id
 });
@@ -10214,6 +12255,50 @@ var worktreeMetadataInput = (input) => compactRecord4({
   autoFixPolicy: input.autoFixPolicy,
   lastReconciledAt: input.lastReconciledAt
 });
+var worktreeMetadataArgs = z.object({
+  worktreeId: z.string().describe("The worktree to update."),
+  id: z.string().optional().describe("Worktree ID alias."),
+  topicId: z.string().optional().describe("Primary topic scope."),
+  additionalTopicIds: z.array(z.string()).optional().describe("Additional topic scopes associated with this worktree."),
+  status: z.string().optional().describe("Worktree lifecycle status."),
+  campaign: z.number().optional().describe("Top-level pipeline campaign."),
+  lane: z.string().optional().describe("Campaign lane."),
+  laneOrderInCampaign: z.number().optional().describe("Ordering for this lane within its campaign."),
+  orderInLane: z.number().optional().describe("Position of this worktree inside its lane."),
+  gate: z.string().optional().describe("Exit gate for this worktree."),
+  hypothesis: z.string().optional().describe("Testable claim this worktree investigates."),
+  objective: z.string().optional().describe("Reasoning objective for the worktree."),
+  rationale: z.string().optional().describe("Why this worktree is sequenced here."),
+  proofArtifacts: z.array(z.unknown()).optional().describe("Proof artifacts required to close the worktree."),
+  staffingHint: z.string().optional().describe("Suggested staffing or agent allocation note."),
+  blocks: z.array(z.string()).optional().describe("Worktree IDs blocked by this worktree."),
+  dependsOn: z.array(z.string()).optional().describe("Worktree IDs this worktree depends on."),
+  lensId: z.string().optional().describe("Lens that scopes this worktree."),
+  autoFixPolicy: autoFixPolicyInputSchema.optional(),
+  lastReconciledAt: z.number().optional().describe("Timestamp of the last deterministic reconciliation pass.")
+});
+var pushArgs = worktreeMetadataArgs.extend({
+  targetContext: z.string().describe("Where to push merged findings."),
+  beliefIds: z.array(z.string()).optional().describe("Optional subset of beliefs to push.")
+});
+var openPullRequestArgs = worktreeMetadataArgs.extend({
+  reviewers: z.array(z.string()).optional().describe("User IDs of requested reviewers."),
+  summary: z.string().describe("Summary of findings and why they are ready for review.")
+});
+var mergeKeyFindingsInput = (input) => {
+  if (Array.isArray(input.keyFindings)) {
+    return input.keyFindings;
+  }
+  if (Array.isArray(input.outcomes)) {
+    const findings = input.outcomes.filter(
+      (outcome) => typeof outcome === "string" && outcome.trim().length > 0
+    );
+    if (findings.length > 0) {
+      return findings;
+    }
+  }
+  return [input.summary ?? "Merged worktree"];
+};
 var listAllWorktreesInput = (input) => compactRecord4({
   status: input.status,
   lane: input.lane,
@@ -10221,6 +12306,16 @@ var listAllWorktreesInput = (input) => compactRecord4({
   limit: input.limit
 });
 var worktreesContracts = [
+  surfaceContract({
+    name: "begin_build_session",
+    kind: "mutation",
+    domain: "worktrees",
+    surfaceClass: "platform_internal",
+    path: "/mcp/build-session/begin",
+    sdkNamespace: "worktrees",
+    sdkMethod: "beginBuildSession",
+    summary: "Begin a coding build session for a worktree."
+  }),
   surfaceContract({
     name: "add_worktree",
     kind: "mutation",
@@ -10237,13 +12332,12 @@ var worktreesContracts = [
       inputProjection: (input, context) => withCreatedBy(
         compactRecord4({
           name: input.name ?? input.title,
-          topicId: input.topicId,
+          topicId: input.topicId ?? input.projectId,
           worktreeType: input.worktreeType,
           objective: input.objective,
           gate: input.gate,
           hypothesis: input.hypothesis,
           rationale: input.rationale,
-          signal: input.signal,
           startDate: input.startDate,
           endDate: input.endDate,
           durationWeeks: input.durationWeeks,
@@ -10269,12 +12363,12 @@ var worktreesContracts = [
           staffingHint: input.staffingHint,
           domainPackId: input.domainPackId,
           lensId: input.lensId,
-          linkedQuestionId: input.linkedQuestionId,
           lastReconciledAt: input.lastReconciledAt
         }),
         context
       )
-    }
+    },
+    args: addWorktreeArgs
   }),
   surfaceContract({
     name: "activate_worktree",
@@ -10386,7 +12480,8 @@ var worktreesContracts = [
       functionName: "updateMetadata",
       kind: "mutation",
       inputProjection: worktreeMetadataInput
-    }
+    },
+    args: worktreeMetadataArgs
   }),
   surfaceContract({
     name: "merge",
@@ -10404,9 +12499,7 @@ var worktreesContracts = [
       inputProjection: (input, context) => withUserId(
         {
           ...worktreeIdInput(input),
-          keyFindings: input.keyFindings ?? [
-            input.summary ?? "Merged worktree"
-          ],
+          keyFindings: mergeKeyFindingsInput(input),
           decisionsReached: input.decisionsReached ?? [],
           nextSteps: input.nextSteps ?? []
         },
@@ -10428,7 +12521,8 @@ var worktreesContracts = [
       functionName: "updateMetadata",
       kind: "mutation",
       inputProjection: worktreeMetadataInput
-    }
+    },
+    args: pushArgs
   }),
   surfaceContract({
     name: "open_pull_request",
@@ -10444,11 +12538,50 @@ var worktreesContracts = [
       functionName: "updateMetadata",
       kind: "mutation",
       inputProjection: worktreeMetadataInput
-    }
+    },
+    args: openPullRequestArgs
   })
 ];
-
-// ../contracts/src/function-registry/tasks.ts
+var taskPrioritySchema = z.enum(["urgent", "high", "medium", "low"]);
+var taskStatusSchema2 = z.enum(["todo", "in_progress", "blocked", "done"]);
+var taskTypeSchema = z.enum([
+  "general",
+  "find_evidence",
+  "verify_claim",
+  "research",
+  "review",
+  "interview",
+  "analysis",
+  "track_metrics"
+]);
+var createTaskArgs = z.object({
+  title: z.string().describe("Task title."),
+  topicId: z.string().optional().describe("Topic scope."),
+  description: z.string().optional().describe("Long-form task description."),
+  taskType: taskTypeSchema.optional().describe("Task taxonomy."),
+  priority: taskPrioritySchema.optional().describe("Priority. Defaults to medium when omitted by the server."),
+  status: taskStatusSchema2.optional().describe("Initial status. Defaults to todo."),
+  linkedWorktreeId: z.string().optional().describe("Worktree this task belongs to."),
+  linkedBeliefId: z.string().optional().describe("Belief this task supports."),
+  linkedQuestionId: z.string().optional().describe("Question this task addresses."),
+  assigneeId: z.string().optional().describe("Principal assigned to the task."),
+  dueDate: z.number().optional().describe("Due date as epoch milliseconds."),
+  tags: z.array(z.string()).optional().describe("Free-form tags.")
+});
+var createTaskInput = (input) => compactRecord4({
+  title: input.title,
+  topicId: input.topicId,
+  description: input.description,
+  taskType: input.taskType,
+  priority: input.priority ?? "medium",
+  status: input.status ?? "todo",
+  linkedWorktreeId: input.linkedWorktreeId,
+  linkedBeliefId: input.linkedBeliefId,
+  linkedQuestionId: input.linkedQuestionId,
+  assigneeId: input.assigneeId,
+  dueDate: input.dueDate,
+  tags: input.tags
+});
 var taskInput = (input) => compactRecord4({
   ...input,
   taskId: input.taskId ?? input.id
@@ -10480,8 +12613,10 @@ var tasksContracts = [
     convex: {
       module: "tasks",
       functionName: "create",
-      kind: "mutation"
-    }
+      kind: "mutation",
+      inputProjection: createTaskInput
+    },
+    args: createTaskArgs
   }),
   surfaceContract({
     name: "list_tasks",
@@ -10535,19 +12670,57 @@ var tasksContracts = [
     }
   })
 ];
+var CREATE_EDGE_TYPES = edgePolicyManifest.policies.map(
+  (policy) => policy.edgeType
+);
 var createEdgeArgs = z.object({
   from: GraphRefSchema,
   to: GraphRefSchema,
-  edgeType: z.string(),
+  edgeType: z.enum(CREATE_EDGE_TYPES),
   globalId: z.string().optional(),
   weight: z.number().optional(),
   confidence: z.number().optional(),
   context: z.string().optional(),
   reasoning: z.string().optional(),
   derivationType: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
   topicId: z.string().optional(),
   trustedBypassAccessCheck: z.boolean().optional()
 });
+var updateEdgeArgs = z.object({
+  edgeId: z.string().describe("Edge ID or global ID."),
+  weight: z.number().optional(),
+  confidence: z.number().optional(),
+  context: z.string().optional(),
+  reasoning: z.string().optional(),
+  derivationType: z.string().optional(),
+  metadata: z.record(z.unknown()).optional(),
+  userId: z.string().optional()
+});
+var removeEdgeArgs = z.object({
+  edgeId: z.string().describe("Edge ID or global ID."),
+  userId: z.string().optional()
+});
+var removeEdgesBetweenArgs = z.object({
+  from: GraphRefSchema.optional(),
+  to: GraphRefSchema.optional(),
+  fromNodeId: z.string().optional(),
+  toNodeId: z.string().optional(),
+  edgeType: z.enum(CREATE_EDGE_TYPES).optional()
+});
+var batchCreateEdgesArgs = z.object({
+  edges: z.array(createEdgeArgs),
+  skipLayerValidation: z.boolean().optional()
+});
+var queryLineageArgs = z.object({
+  nodeId: z.string().describe("Starting node to trace from."),
+  startNode: z.string().optional().describe("Starting node alias accepted by traversal callers."),
+  depth: z.number().optional().describe("Traversal depth alias."),
+  maxDepth: z.number().optional().describe("Maximum traversal depth."),
+  mode: z.string().optional().describe("Traversal mode."),
+  minLayer: z.string().optional().describe("Minimum epistemic layer."),
+  maxLayer: z.string().optional().describe("Maximum epistemic layer.")
+});
 function graphRefNodeId(ref) {
   if (ref.kind === "epistemic_node") {
     return ref.nodeId;
@@ -10588,6 +12761,7 @@ var edgesContracts = [
             confidence: parsed.confidence,
             context: parsed.context ?? parsed.reasoning,
             derivationType: parsed.derivationType,
+            metadata: parsed.metadata,
             skipLayerValidation: true,
             topicId: parsed.topicId,
             trustedBypassAccessCheck: parsed.trustedBypassAccessCheck
@@ -10598,6 +12772,130 @@ var edgesContracts = [
     },
     args: createEdgeArgs
   }),
+  surfaceContract({
+    name: "update_edge",
+    kind: "mutation",
+    domain: "edges",
+    surfaceClass: "platform_public",
+    method: "PATCH",
+    path: "/edges",
+    sdkNamespace: "edges",
+    sdkMethod: "updateEdge",
+    summary: "Update an epistemic edge.",
+    convex: {
+      module: "edges",
+      functionName: "update",
+      kind: "mutation",
+      inputProjection: (input, context) => compactRecord4({
+        edgeId: input.edgeId,
+        weight: input.weight,
+        confidence: input.confidence,
+        context: input.context ?? input.reasoning,
+        derivationType: input.derivationType,
+        metadata: input.metadata,
+        userId: input.userId ?? context.userId ?? context.principalId
+      })
+    },
+    args: updateEdgeArgs
+  }),
+  surfaceContract({
+    name: "remove_edge",
+    kind: "mutation",
+    domain: "edges",
+    surfaceClass: "platform_public",
+    method: "DELETE",
+    path: "/edges",
+    sdkNamespace: "edges",
+    sdkMethod: "removeEdge",
+    summary: "Remove an epistemic edge.",
+    convex: {
+      module: "edges",
+      functionName: "remove",
+      kind: "mutation",
+      inputProjection: (input, context) => compactRecord4({
+        edgeId: input.edgeId,
+        userId: input.userId ?? context.userId ?? context.principalId
+      })
+    },
+    args: removeEdgeArgs
+  }),
+  surfaceContract({
+    name: "remove_edges_between",
+    kind: "mutation",
+    domain: "edges",
+    surfaceClass: "platform_public",
+    method: "DELETE",
+    path: "/edges/between",
+    sdkNamespace: "edges",
+    sdkMethod: "removeEdgesBetween",
+    summary: "Remove epistemic edges between two nodes.",
+    convex: {
+      module: "edges",
+      functionName: "removeBetween",
+      kind: "mutation",
+      inputProjection: (input) => {
+        const parsed = removeEdgesBetweenArgs.parse(input);
+        const fromNodeId = parsed.from ? graphRefNodeId(parsed.from) : parsed.fromNodeId;
+        const toNodeId = parsed.to ? graphRefNodeId(parsed.to) : parsed.toNodeId;
+        if (!fromNodeId || !toNodeId) {
+          throw new Error("from/to or fromNodeId/toNodeId are required.");
+        }
+        return compactRecord4({
+          fromNodeId,
+          toNodeId,
+          edgeType: parsed.edgeType
+        });
+      }
+    },
+    args: removeEdgesBetweenArgs
+  }),
+  surfaceContract({
+    name: "batch_create_edges",
+    kind: "mutation",
+    domain: "edges",
+    surfaceClass: "platform_public",
+    path: "/edges/batch",
+    sdkNamespace: "edges",
+    sdkMethod: "batchCreateEdges",
+    summary: "Batch create epistemic edges.",
+    convex: {
+      module: "edges",
+      functionName: "batchCreate",
+      kind: "mutation",
+      inputProjection: (input, context) => {
+        const parsed = batchCreateEdgesArgs.parse(input);
+        return {
+          skipLayerValidation: parsed.skipLayerValidation ?? true,
+          edges: parsed.edges.map((edge) => {
+            assertEdgePolicyAllowed(
+              edgePolicyManifest,
+              edge.edgeType,
+              edge.from,
+              edge.to
+            );
+            const fromNodeId = graphRefNodeId(edge.from);
+            const toNodeId = graphRefNodeId(edge.to);
+            return withCreatedBy(
+              compactRecord4({
+                fromNodeId,
+                toNodeId,
+                edgeType: edge.edgeType,
+                globalId: edge.globalId ?? `edge:${fromNodeId}:${toNodeId}:${edge.edgeType}`,
+                weight: edge.weight,
+                confidence: edge.confidence,
+                context: edge.context ?? edge.reasoning,
+                derivationType: edge.derivationType,
+                metadata: edge.metadata,
+                topicId: edge.topicId
+              }),
+              context
+            );
+          })
+        };
+      }
+    },
+    args: batchCreateEdgesArgs
+  }),
   surfaceContract({
     name: "query_lineage",
     kind: "query",
@@ -10618,11 +12916,84 @@ var edgesContracts = [
         minLayer: input.minLayer,
         maxLayer: input.maxLayer
       })
-    }
+    },
+    args: queryLineageArgs
   })
 ];
-
-// ../contracts/src/function-registry/graph.ts
+var graphIntelligenceQueryModes = [
+  "core",
+  "bias",
+  "stress",
+  "operational",
+  "alpha",
+  "semantic",
+  "evidence"
+];
+var traversalLayerSchema = z.enum([
+  "L4",
+  "L3",
+  "L2",
+  "L1",
+  "ontological",
+  "organizational"
+]);
+var traversalModeSchema = z.enum(["low", "medium", "high", "extra_high"]);
+var lineageAliasArgs = z.object({
+  nodeId: z.string().optional().describe("Starting node to traverse from."),
+  startNode: z.string().optional().describe("Starting node alias for traversal callers."),
+  entityId: z.string().optional().describe("Entity identifier alias for impact tracing."),
+  depth: z.number().optional().describe("Traversal depth alias."),
+  maxDepth: z.number().optional().describe("Maximum traversal depth."),
+  mode: traversalModeSchema.optional().describe("Traversal mode."),
+  minLayer: traversalLayerSchema.optional().describe("Minimum epistemic layer to include."),
+  maxLayer: traversalLayerSchema.optional().describe("Maximum epistemic layer to include.")
+});
+var lineageArgs = lineageAliasArgs.extend({
+  nodeId: z.string().describe("Starting node to traverse from.")
+});
+var traverseGraphArgs = lineageAliasArgs.extend({
+  startNode: z.string().describe("Node to start traversal from."),
+  direction: z.enum(["up", "down", "both"]).optional().describe("Traversal direction.")
+});
+var graphNeighborhoodArgs = z.object({
+  globalId: z.string().optional().describe("Single root global ID."),
+  globalIds: z.array(z.string()).optional().describe("Root global IDs for the neighborhood."),
+  maxDepth: z.number().optional().describe("Maximum traversal depth."),
+  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."),
+  topicId: z.string().optional().describe("Topic scope for the contradiction."),
+  description: z.string().optional().describe("Human-readable contradiction."),
+  severity: z.enum(["critical", "high", "medium", "low"]).optional().describe("Contradiction severity."),
+  defeatType: z.string().optional().describe("Defeat type annotation."),
+  supportingInsightIds: z.array(z.string()).optional().describe("Evidence supporting the primary belief."),
+  contradictingInsightIds: z.array(z.string()).optional().describe("Evidence or beliefs contradicting the primary belief.")
+});
+var discoverEntityConnectionsArgs = lineageAliasArgs.extend({
+  nodeId: z.string().describe("Epistemic node ID to find entity connections for."),
+  topicId: z.string().optional().describe("Topic scope override."),
+  minScore: z.number().optional().describe("Minimum match score."),
+  limit: z.number().optional().describe("Maximum candidates to return.")
+});
 var contradictionSeverity = (value) => {
   switch (value) {
     case "critical":
@@ -10677,7 +13048,8 @@ var graphContracts = [
       functionName: "getLineage",
       kind: "query",
       inputProjection: lineageInput
-    }
+    },
+    args: traverseGraphArgs
   }),
   surfaceContract({
     name: "get_graph_neighborhood",
@@ -10693,7 +13065,8 @@ var graphContracts = [
       functionName: "getByTopic",
       kind: "query",
       inputProjection: topicEdgesInput
-    }
+    },
+    args: graphNeighborhoodArgs
   }),
   surfaceContract({
     name: "get_graph_structure_analysis",
@@ -10710,6 +13083,38 @@ var graphContracts = [
       kind: "query"
     }
   }),
+  surfaceContract({
+    name: "list_graph_intelligence_queries",
+    kind: "query",
+    domain: "graph",
+    surfaceClass: "platform_public",
+    path: "/graph-intelligence/queries",
+    sdkNamespace: "graphAnalysis",
+    sdkMethod: "listGraphIntelligenceQueries",
+    summary: "List Graph Intelligence query catalog entries.",
+    convex: {
+      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",
@@ -10742,7 +13147,8 @@ var graphContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: flagContradictionInput
-    }
+    },
+    args: flagContradictionArgs
   }),
   surfaceContract({
     name: "detect_confirmation_bias",
@@ -10833,7 +13239,8 @@ var graphContracts = [
       functionName: "getLineage",
       kind: "query",
       inputProjection: lineageInput
-    }
+    },
+    args: discoverEntityConnectionsArgs
   }),
   surfaceContract({
     name: "trigger_belief_review",
@@ -10864,7 +13271,8 @@ var graphContracts = [
       functionName: "getLineage",
       kind: "query",
       inputProjection: lineageInput
-    }
+    },
+    args: lineageArgs
   })
 ];
 
@@ -10916,8 +13324,16 @@ var contractsContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/judgments.ts
+var auditTrailArgs = z.object({
+  nodeId: z.string().describe("The node to audit."),
+  id: z.string().optional().describe("Node ID alias."),
+  limit: z.number().optional().describe("Maximum entries to return."),
+  depth: z.number().optional().describe("Traversal depth alias."),
+  maxDepth: z.number().optional().describe("Maximum lineage depth."),
+  mode: z.string().optional().describe("Traversal mode."),
+  minLayer: z.string().optional().describe("Minimum epistemic layer."),
+  maxLayer: z.string().optional().describe("Maximum epistemic layer.")
+});
 var judgmentsContracts = [
   surfaceContract({
     name: "record_judgment",
@@ -10972,7 +13388,8 @@ var judgmentsContracts = [
         minLayer: input.minLayer,
         maxLayer: input.maxLayer
       })
-    }
+    },
+    args: auditTrailArgs
   })
 ];
 
@@ -11140,8 +13557,13 @@ var coordinationContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/pipeline.ts
+var pipelineSnapshotArgs = z.object({
+  topicId: z.string().describe("Topic scope ID."),
+  status: z.string().optional().describe("Worktree status filter."),
+  lane: z.string().optional().describe("Campaign lane filter."),
+  campaign: z.number().optional().describe("Campaign number filter."),
+  limit: z.number().optional().describe("Maximum worktrees to inspect.")
+});
 var pipelineContracts = [
   surfaceContract({
     name: "pipeline_snapshot",
@@ -11162,7 +13584,8 @@ var pipelineContracts = [
         campaign: input.campaign,
         limit: input.limit
       })
-    }
+    },
+    args: pipelineSnapshotArgs
   }),
   surfaceContract({
     name: "seed_belief_lattice",
@@ -11214,7 +13637,31 @@ var recordScopeLearningArgs = z.object({
   rationale: z.string().optional().describe("Why this learning should enter the reasoning graph"),
   createQuestionText: z.string().optional().describe("Optional follow-up question text"),
   createBeliefText: z.string().optional().describe("Optional new belief text"),
-  beliefType: z.string().optional().describe("Optional belief type for createBeliefText")
+  beliefType: z.string().optional().describe("Optional belief type for createBeliefText"),
+  text: z.string().optional().describe("Canonical learning text alias."),
+  content: z.string().optional().describe("Canonical learning content alias."),
+  kind: z.string().optional().describe("Evidence kind to store."),
+  sourceType: z.string().optional().describe("Evidence source type."),
+  externalSourceType: z.string().optional().describe("External source type alias."),
+  metadata: z.record(z.unknown()).optional().describe("Learning metadata.")
+});
+var codeContextArgs = z.object({
+  topicId: z.string().optional().describe("Topic scope."),
+  filePath: z.string().optional().describe("File path anchor."),
+  includeFailures: z.boolean().optional().describe("Whether to include failed attempts."),
+  limit: z.number().optional().describe("Maximum records to return."),
+  status: z.string().optional().describe("Evidence status filter.")
+});
+var recordAttemptArgs = z.object({
+  topicId: z.string().optional().describe("Topic scope."),
+  description: z.string().describe("Attempt description."),
+  errorMessage: z.string().optional().describe("Failure or error message."),
+  filePaths: z.array(z.string()).optional().describe("Files involved in the attempt."),
+  filePath: z.string().optional().describe("Single file path alias."),
+  linkedBeliefId: z.string().optional().describe("Linked belief ID."),
+  metadata: z.record(z.unknown()).optional().describe("Attempt metadata."),
+  rationale: z.string().optional().describe("Why this attempt should be recorded."),
+  title: z.string().optional().describe("Attempt evidence title.")
 });
 var learningInput = (input, context) => {
   const sourceKind = input.sourceKind ?? input.externalSourceType;
@@ -11331,7 +13778,8 @@ var codingContracts = [
         status: input.status,
         userId: input.userId
       })
-    }
+    },
+    args: codeContextArgs
   }),
   surfaceContract({
     name: "get_change_history",
@@ -11368,7 +13816,8 @@ var codingContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: attemptInput
-    }
+    },
+    args: recordAttemptArgs
   }),
   surfaceContract({
     name: "get_failure_log",
@@ -11425,6 +13874,7 @@ var ALL_FUNCTION_CONTRACTS = [
   ...evidenceContracts,
   ...questionsContracts,
   ...topicsContracts,
+  ...nodesContracts,
   ...lensesContracts,
   ...ontologiesContracts,
   ...worktreesContracts,
@@ -11439,9 +13889,610 @@ var ALL_FUNCTION_CONTRACTS = [
   ...legacyContracts
 ];
 assertSurfaceCoverage(ALL_FUNCTION_CONTRACTS);
-new Map(
+var FUNCTION_CONTRACTS_BY_NAME = new Map(
   ALL_FUNCTION_CONTRACTS.map((contract) => [contract.name, contract])
 );
+FUNCTION_CONTRACTS_BY_NAME.get.bind(
+  FUNCTION_CONTRACTS_BY_NAME
+);
+
+// ../contracts/src/tenant-bootstrap-seed.contract.ts
+function isCopyableSeedRequirement(entry) {
+  return (entry.copyMode === "template_global" || entry.copyMode === "template_tenant_rewrite" || entry.copyMode === "template_reference_remap") && Boolean(entry.scope) && Array.isArray(entry.uniqueKey) && entry.uniqueKey.length > 0;
+}
+var TENANT_BOOTSTRAP_TABLE_REQUIREMENTS = [
+  {
+    component: "kernel",
+    table: "agentMessages",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Agent coordination messages are session data, not template data."
+  },
+  {
+    component: "kernel",
+    table: "agentSessions",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Agent coordination sessions are created by active clients."
+  },
+  {
+    component: "kernel",
+    table: "autofixJobs",
+    prepopulation: "runtime_queue",
+    copyMode: "none",
+    description: "Autofix work items are runtime queue rows."
+  },
+  {
+    component: "kernel",
+    table: "backgroundJobRuns",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Background job executions are runtime logs."
+  },
+  {
+    component: "kernel",
+    table: "backgroundJobSettings",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["jobKey"],
+    description: "Default job enablement settings must come from the K template."
+  },
+  {
+    component: "kernel",
+    table: "beliefConfidence",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Belief confidence rows are created with tenant graph facts."
+  },
+  {
+    component: "kernel",
+    table: "beliefEvidenceLinks",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Belief-to-evidence links are tenant graph data."
+  },
+  {
+    component: "kernel",
+    table: "beliefHistory",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Belief history is append-only tenant graph data."
+  },
+  {
+    component: "kernel",
+    table: "beliefScenarios",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Scenario rows are tenant-authored reasoning data."
+  },
+  {
+    component: "kernel",
+    table: "beliefVotes",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Decision belief votes are tenant-authored data."
+  },
+  {
+    component: "kernel",
+    table: "calibrationScores",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Calibration scores are computed from tenant outcomes."
+  },
+  {
+    component: "kernel",
+    table: "contractEvaluations",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Contract evaluation rows are runtime computation logs."
+  },
+  {
+    component: "kernel",
+    table: "contradictions",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Contradictions are tenant graph facts."
+  },
+  {
+    component: "kernel",
+    table: "crossProjectConnections",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Cross-topic connections are tenant graph facts."
+  },
+  {
+    component: "kernel",
+    table: "decisionComputedSummaries",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Decision summaries are derived tenant outputs."
+  },
+  {
+    component: "kernel",
+    table: "decisionEvents",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Decision events are lifecycle data."
+  },
+  {
+    component: "kernel",
+    table: "decisionParticipants",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Decision participants are tenant-selected actors."
+  },
+  {
+    component: "kernel",
+    table: "decisionRiskLedger",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Decision risk rows are tenant decision data."
+  },
+  {
+    component: "kernel",
+    table: "decisionSnapshots",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Decision snapshots are derived from tenant state."
+  },
+  {
+    component: "kernel",
+    table: "deliberationContributions",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Deliberation contributions are tenant-authored data."
+  },
+  {
+    component: "kernel",
+    table: "deliberationSessions",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Deliberation sessions are created by tenant workflows."
+  },
+  {
+    component: "kernel",
+    table: "epistemicAudit",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Epistemic audit rows are append-only runtime audit data."
+  },
+  {
+    component: "kernel",
+    table: "epistemicContracts",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Epistemic contracts are tenant-authored governance data."
+  },
+  {
+    component: "kernel",
+    table: "epistemicEdges",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Edges are tenant reasoning graph data."
+  },
+  {
+    component: "kernel",
+    table: "epistemicNodeEmbeddings",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Embeddings are derived from tenant graph nodes."
+  },
+  {
+    component: "kernel",
+    table: "epistemicNodes",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Nodes are tenant reasoning graph data."
+  },
+  {
+    component: "kernel",
+    table: "graphAnalysisCache",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Graph analysis cache rows are derived from tenant graph state."
+  },
+  {
+    component: "kernel",
+    table: "graphAnalysisResults",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Graph analysis result rows are derived tenant outputs."
+  },
+  {
+    component: "kernel",
+    table: "graphSuggestions",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Graph suggestions are derived recommendations."
+  },
+  {
+    component: "kernel",
+    table: "harnessReplays",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Harness replay rows are runtime verification logs."
+  },
+  {
+    component: "kernel",
+    table: "harnessRuns",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Harness run rows are runtime verification logs."
+  },
+  {
+    component: "kernel",
+    table: "idempotencyTokens",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Idempotency tokens are request-scoped runtime guards."
+  },
+  {
+    component: "kernel",
+    table: "lenses",
+    prepopulation: "optional_template",
+    copyMode: "none",
+    description: "Reusable lens templates may live in K templates, but workspace-specific copies are not required for core SDK boot."
+  },
+  {
+    component: "kernel",
+    table: "lensTopicBindings",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Lens bindings attach runtime topics to runtime/workspace lenses."
+  },
+  {
+    component: "kernel",
+    table: "neo4jSyncQueue",
+    prepopulation: "runtime_queue",
+    copyMode: "none",
+    description: "Neo4j sync queue rows are runtime work items."
+  },
+  {
+    component: "kernel",
+    table: "ontologyDefinitions",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["ontologyKey"],
+    description: "Platform ontology definitions power taxonomy reads and effective ontology resolution."
+  },
+  {
+    component: "kernel",
+    table: "ontologyVersions",
+    prepopulation: "required_template",
+    copyMode: "template_reference_remap",
+    scope: "global",
+    uniqueKey: ["ontologyKey", "version"],
+    dependsOn: ["ontologyDefinitions"],
+    description: "Ontology versions must be copied with ontologyDefinition ID remapping."
+  },
+  {
+    component: "kernel",
+    table: "platformAgentRunPolicyDecisions",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Agent-run policy decisions are audit logs."
+  },
+  {
+    component: "kernel",
+    table: "platformAgentRunPromptResolutions",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Agent-run prompt resolution rows are runtime logs."
+  },
+  {
+    component: "kernel",
+    table: "platformAgentRuns",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Agent runs are runtime execution records."
+  },
+  {
+    component: "kernel",
+    table: "platformAgentRunToolCalls",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Agent-run tool calls are runtime execution records."
+  },
+  {
+    component: "kernel",
+    table: "platformHarnessShadowAudit",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Harness shadow audit rows are runtime audit records."
+  },
+  {
+    component: "kernel",
+    table: "publicationRules",
+    prepopulation: "required_template",
+    copyMode: "template_tenant_rewrite",
+    scope: "tenant",
+    uniqueKey: ["tenantId", "workspaceId", "name"],
+    description: "Default publication policy rules are rewritten into each tenant."
+  },
+  {
+    component: "kernel",
+    table: "questionEvidenceLinks",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Question-to-evidence links are tenant graph data."
+  },
+  {
+    component: "kernel",
+    table: "researchJobs",
+    prepopulation: "runtime_queue",
+    copyMode: "none",
+    description: "Research job rows are runtime queue items."
+  },
+  {
+    component: "kernel",
+    table: "schemaEnumConfig",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["category", "value"],
+    description: "Runtime-extensible enum defaults required by SDK graph APIs."
+  },
+  {
+    component: "kernel",
+    table: "stakeholderGroups",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Stakeholder groups are tenant decision data."
+  },
+  {
+    component: "kernel",
+    table: "systemLogs",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "System logs are runtime telemetry."
+  },
+  {
+    component: "kernel",
+    table: "tasks",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Tasks are tenant-authored work items."
+  },
+  {
+    component: "kernel",
+    table: "topics",
+    prepopulation: "runtime_bootstrap",
+    copyMode: "none",
+    description: "Default topics are created by tenant provisioning, not copied from templates."
+  },
+  {
+    component: "kernel",
+    table: "workflowDefinitions",
+    prepopulation: "optional_template",
+    copyMode: "none",
+    description: "Table-driven workflow definitions can be template data after the workflow engine leaves legacy mode."
+  },
+  {
+    component: "kernel",
+    table: "workflowPullRequests",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Workflow pull requests are tenant workflow data."
+  },
+  {
+    component: "kernel",
+    table: "workflowStages",
+    prepopulation: "optional_template",
+    copyMode: "none",
+    dependsOn: ["workflowDefinitions"],
+    description: "Workflow stages can be template data after workflowDefinitions are enabled for bootstrap copying."
+  },
+  {
+    component: "kernel",
+    table: "worktreeBeliefCluster",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Worktree cluster rows link runtime worktrees to runtime beliefs."
+  },
+  {
+    component: "kernel",
+    table: "worktrees",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Worktrees are tenant/runtime planning data."
+  },
+  {
+    component: "identity",
+    table: "agents",
+    prepopulation: "runtime_bootstrap",
+    copyMode: "none",
+    description: "Service agents are provisioned per tenant or service, not copied."
+  },
+  {
+    component: "identity",
+    table: "mcpWritePolicy",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["topicId", "role", "toolCategory"],
+    description: "Global write policy defaults govern service and interactive MCP writes."
+  },
+  {
+    component: "identity",
+    table: "modelCallLogs",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Model call logs are runtime telemetry."
+  },
+  {
+    component: "identity",
+    table: "modelFunctionSlots",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["slot"],
+    description: "Function-to-model slots are required by model runtime resolution."
+  },
+  {
+    component: "identity",
+    table: "modelRegistry",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["key"],
+    description: "Model catalog defaults are required by model runtime clients."
+  },
+  {
+    component: "identity",
+    table: "modelSlotConfigs",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["slot"],
+    description: "Slot-level defaults are required before tenant overrides exist."
+  },
+  {
+    component: "identity",
+    table: "platformAudienceGrants",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Audience grants are principal/group-specific access rows."
+  },
+  {
+    component: "identity",
+    table: "platformAudiences",
+    prepopulation: "required_template",
+    copyMode: "template_tenant_rewrite",
+    scope: "tenant",
+    uniqueKey: ["tenantId", "workspaceId", "audienceKey"],
+    description: "Default tenant audience taxonomy rows are rewritten into each tenant."
+  },
+  {
+    component: "identity",
+    table: "platformPolicyDecisionLogs",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Policy decisions are runtime audit logs."
+  },
+  {
+    component: "identity",
+    table: "projectGrants",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Project/topic grants are principal or group-specific access rows."
+  },
+  {
+    component: "identity",
+    table: "reasoningPermissions",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Reasoning permissions are principal-specific policy rows."
+  },
+  {
+    component: "identity",
+    table: "tenantApiKeys",
+    prepopulation: "runtime_secret",
+    copyMode: "none",
+    description: "API keys are tenant credentials and must never be copied."
+  },
+  {
+    component: "identity",
+    table: "tenantConfig",
+    prepopulation: "required_template",
+    copyMode: "template_tenant_rewrite",
+    scope: "tenant",
+    uniqueKey: ["tenantId"],
+    description: "Tenant-local config defaults are rewritten during bootstrap."
+  },
+  {
+    component: "identity",
+    table: "tenantIntegrations",
+    prepopulation: "required_template",
+    copyMode: "template_tenant_rewrite",
+    scope: "tenant",
+    uniqueKey: ["tenantId", "integrationKey"],
+    description: "Non-secret integration descriptors are rewritten into each tenant."
+  },
+  {
+    component: "identity",
+    table: "tenantModelSlotBindings",
+    prepopulation: "runtime_secret",
+    copyMode: "none",
+    description: "Tenant model slot bindings reference provider secrets and are runtime-only."
+  },
+  {
+    component: "identity",
+    table: "tenantPolicies",
+    prepopulation: "required_template",
+    copyMode: "template_tenant_rewrite",
+    scope: "tenant",
+    uniqueKey: ["tenantId", "workspaceId", "roleName"],
+    description: "Default tenant policy roles are rewritten during bootstrap."
+  },
+  {
+    component: "identity",
+    table: "tenantProviderSecrets",
+    prepopulation: "runtime_secret",
+    copyMode: "none",
+    description: "Provider secrets are credentials and must never be copied."
+  },
+  {
+    component: "identity",
+    table: "tenantProxyGatewayUsage",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Proxy gateway usage rows are runtime telemetry."
+  },
+  {
+    component: "identity",
+    table: "tenantProxyTokenMints",
+    prepopulation: "runtime_secret",
+    copyMode: "none",
+    description: "Proxy token mints are ephemeral secret-bearing runtime rows."
+  },
+  {
+    component: "identity",
+    table: "tenantSandboxAuditEvents",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Sandbox audit rows are runtime security logs."
+  },
+  {
+    component: "identity",
+    table: "tenantSecrets",
+    prepopulation: "runtime_secret",
+    copyMode: "none",
+    description: "Tenant secrets are credentials and must never be copied."
+  },
+  {
+    component: "identity",
+    table: "toolAcls",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["role", "toolName"],
+    description: "Default role-to-tool grants are required for SDK/MCP tool access."
+  },
+  {
+    component: "identity",
+    table: "toolRegistry",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["toolName"],
+    description: "Core tool catalog rows are required before pack or tenant tools exist."
+  },
+  {
+    component: "identity",
+    table: "users",
+    prepopulation: "runtime_bootstrap",
+    copyMode: "none",
+    description: "Users are created from Clerk/MC principal resolution, not copied."
+  }
+];
+TENANT_BOOTSTRAP_TABLE_REQUIREMENTS.filter(
+  isCopyableSeedRequirement
+);
+TENANT_BOOTSTRAP_TABLE_REQUIREMENTS.filter(
+  (entry) => !isCopyableSeedRequirement(entry)
+).map((entry) => entry.table);
 
 export { DOMAIN_EVENT_TYPES, DOMAIN_EVENT_VERSION, EVENT_RETENTION_DEFAULT_DAYS, WEBHOOK_MAX_ATTEMPTS, WEBHOOK_RETRY_DELAYS_MS };
 //# sourceMappingURL=types.js.map