@lucern/events 1.0.11 → 1.0.13

package/dist/webhooks.js

@@ -546,7 +546,7 @@ var SEARCH_EVIDENCE = {
 };
 var CREATE_EVIDENCE = {
   name: "create_evidence",
-  description: "Commit evidence to the reasoning graph. Like `git commit` \u2014 creates a traceable evidence record with canonical public IDs. Optionally links the evidence to a belief or question in the same operation.",
+  description: "Commit evidence to the reasoning graph. Like `git commit` \u2014 creates a traceable evidence record with canonical public IDs. Optionally links the evidence to a belief or question in the same operation. When evidence bears on beliefs, state whether it supports or contradicts; SL confidence is derived from these evidence relations.",
   parameters: {
     topicId: { type: "string", description: "Topic scope" },
     text: { type: "string", description: "Canonical evidence text" },
@@ -557,7 +557,20 @@ var CREATE_EVIDENCE = {
     },
     weight: {
       type: "number",
-      description: "Support weight: -1.0 (contradicts) to +1.0 (supports)"
+      description: "Optional support weight: -1.0 (contradicts) to +1.0 (supports). If omitted, evidenceRelation + confidence determine the weight."
+    },
+    evidenceRelation: {
+      type: "string",
+      enum: ["supports", "contradicts"],
+      description: "Canonical relation to targetId/linkedBeliefNodeId. Prefer this over relying on signed weight inference."
+    },
+    confidence: {
+      type: "number",
+      description: "Confidence in the evidence relation, 0.0 to 1.0"
+    },
+    beliefRelations: {
+      type: "array",
+      description: "Optional additional belief relations: [{ beliefId|beliefNodeId|targetId, evidenceRelation|relation, confidence?, weight?, rationale? }]. Use one evidence node with multiple relations when the same fact supports or contradicts several beliefs."
     },
     metadata: {
       type: "object",
@@ -667,7 +680,7 @@ var LINK_EVIDENCE = {
 };
 var LINK_EVIDENCE_TO_BELIEF = {
   name: "link_evidence_to_belief",
-  description: "Link evidence to a belief with a support weight. Like `git add` \u2014 stages evidence in support of (or against) a belief. The weight ranges from -1.0 (strongly contradicts) to +1.0 (strongly supports).",
+  description: "Link evidence to a belief with a support weight. Like `git add` \u2014 stages evidence in support of (or against) a belief. The weight ranges from -1.0 (strongly contradicts) to +1.0 (strongly supports). This relation appends to the SL confidence ledger; do not hand-write confidence separately.",
   parameters: {
     evidenceId: { type: "string", description: "The evidence node ID" },
     beliefId: { type: "string", description: "The belief node ID" },
@@ -675,9 +688,18 @@ var LINK_EVIDENCE_TO_BELIEF = {
       type: "number",
       description: "Support weight: -1.0 (contradicts) to +1.0 (supports)"
     },
+    evidenceRelation: {
+      type: "string",
+      enum: ["supports", "contradicts"],
+      description: "Canonical semantic relation. If omitted, the sign of weight is used."
+    },
+    confidence: {
+      type: "number",
+      description: "Confidence in this evidence-to-belief relation, 0.0 to 1.0"
+    },
     rationale: { type: "string", description: "Why this evidence is relevant" }
   },
-  required: ["evidenceId", "beliefId", "weight"],
+  required: ["evidenceId", "beliefId"],
   response: {
     description: "The created edge linking evidence to belief",
     fields: {
@@ -695,7 +717,7 @@ var LINK_EVIDENCE_TO_BELIEF = {
 // ../contracts/src/tool-contracts.lifecycle.ts
 var CREATE_BELIEF = {
   name: "create_belief",
-  description: "Commit a new belief (knowledge unit) to the reasoning graph. Like `git commit` \u2014 creates an atomic, traceable knowledge object with a prior. Creation stores the vacuous opinion `(0, 0, 1, a)`; use modulate_confidence to record the first evidential update.",
+  description: "Commit a new belief (knowledge unit) to the reasoning graph. Like `git commit` \u2014 creates an atomic, traceable knowledge object with a prior. Creation stores the vacuous opinion `(0, 0, 1, a)`; attach supporting or contradicting evidence with create_evidence or link_evidence_to_belief to record evidential updates.",
   parameters: {
     canonicalText: {
       type: "string",
@@ -781,7 +803,7 @@ var REFINE_BELIEF = {
 };
 var MODULATE_CONFIDENCE = {
   name: "modulate_confidence",
-  description: "Record a confidence change for a belief. Like `git commit` to the credence log \u2014 an atomic, append-only write. Each modulation is a new entry in the history, not an overwrite. Scoring happens via merge; this tool records the individual data points. Pass the full subjective-logic tuple (`belief`, `disbelief`, `uncertainty`, `baseRate`) directly. If a caller only has a scalar probability, use `@lucern/sdk` helpers `opinionFromBaseRate`, `opinionFromDogmatic`, or `opinionFromProjected` to name the intended interpretation before calling this tool. Every modulation must cite a truth-bearing artifact: triggeringEvidenceId, triggeringQuestionId, triggeringAnswerId, triggeringContradictionId, or triggeringWorktreeId. Triggers: evidence_added, evidence_removed, contradiction_detected, contradiction_resolved, agent_assessment, worktree_outcome, worktree_completed, fusion, discount, deduction.",
+  description: "Internal-only subjective-logic ledger append. Like `git commit` to the credence log for the scoring engine \u2014 never an operator-facing way to assert confidence. Agents, SDK callers, CLI users, and MCP clients must instead create or link evidence with `evidenceRelation: supports|contradicts`; the kernel derives the next opinion from that evidence. This compatibility primitive is reserved for governed system scoring paths that already hold a full subjective-logic tuple and truth-bearing provenance.",
   parameters: {
     nodeId: { type: "string", description: "The belief to score" },
     belief: {
@@ -1430,6 +1452,60 @@ var REMOVE_LENS_FROM_TOPIC = {
   tier: "workhorse"
 };
 
+// ../contracts/src/tool-contracts.context-orientation.ts
+var LUCERN_ORIENT = {
+  name: "lucern_orient",
+  description: "Load the Lucern reasoning grammar before operating. Like `git help` plus a repository CONTRIBUTING guide for reasoning state - teaches the git-shaped model of topics, campaigns, lanes, worktrees, beliefs, questions, evidence, receipts, gates, and merges.",
+  parameters: {
+    audience: {
+      type: "string",
+      description: "Audience for the primer: agent, human, operator, or developer.",
+      enum: ["agent", "human", "operator", "developer"]
+    },
+    depth: {
+      type: "string",
+      description: "Orientation depth: quick, standard, or deep.",
+      enum: ["quick", "standard", "deep"]
+    },
+    situation: {
+      type: "string",
+      description: "Optional task or query context used to tailor suggested next calls."
+    },
+    includeExamples: {
+      type: "boolean",
+      description: "Whether to include concrete tool-call examples."
+    },
+    includeToolMap: {
+      type: "boolean",
+      description: "Whether to include situation-to-tool routing guidance."
+    },
+    includeFuture: {
+      type: "boolean",
+      description: "Whether to include future exemplar, gauntlet, and training-data capabilities."
+    }
+  },
+  required: [],
+  response: {
+    description: "Canonical operator primer for Lucern's git-shaped reasoning substrate.",
+    fields: {
+      schemaVersion: "string - lucern_orientation.v1",
+      canonicalMentalModel: "object - concise model of Lucern as git-shaped reasoning state",
+      workflow: "array - recommended branch -> investigate -> prove gate -> merge workflow",
+      grammarMap: "array - primitive-to-git-analogy map for topics, campaigns, worktrees, beliefs, questions, evidence, edges, contradictions, and gates",
+      firstMoves: "array - recommended first tools for a cold-start agent",
+      receiptRules: "array - how to interpret candidateCounts, broadening, coverageWarning, narrativeCoverage, synthesisLints, and noDefaultGlobalScan",
+      safetyRules: "array - mutation and completion rules that preserve reasoning lineage",
+      toolMap: "array | undefined - situation-to-tool routing map when requested",
+      examples: "array | undefined - concrete tool-call examples when requested",
+      futureCapabilities: "array | undefined - exemplar, gauntlet, trace-corpus, and native-model-training capabilities when requested",
+      suggestedNextCalls: "array - safe next tool calls for the current situation"
+    }
+  },
+  ownerModule: "reasoning-kernel",
+  ontologyPrimitive: "graph",
+  tier: "showcase"
+};
+
 // ../contracts/src/tool-contracts.ontology.ts
 var MANAGE_WRITE_POLICY = {
   name: "manage_write_policy",
@@ -3939,10 +4015,34 @@ var COMPILE_CONTEXT = {
       type: "string",
       description: "Optional source kind used as a resolver signal, such as cli, worktree, commit, or docs."
     },
+    campaign: {
+      type: "number",
+      description: "Optional campaign dimension seed. When supplied without topicId, the compiler fans out across all carrier topics for that campaign instead of resolving a single topic."
+    },
+    lane: {
+      type: "string",
+      description: "Optional lane dimension seed. When supplied without topicId, the compiler reads all matching worktrees and their carrier topics."
+    },
+    status: {
+      type: "string",
+      description: "Optional state/status dimension seed for worktrees and graph rows."
+    },
+    principalId: {
+      type: "string",
+      description: "Optional principal seed for work authored, touched, or owned by a human, agent, group, or service principal."
+    },
+    workspaceId: {
+      type: "string",
+      description: "Optional workspace seed used by hosted MCP and SDK clients when compiling tenant-scoped context."
+    },
     budget: {
       type: "number",
       description: "Token budget for prompt injection planning"
     },
+    tokenBudget: {
+      type: "number",
+      description: "Compatibility alias for budget. External MCP clients may send tokenBudget when requesting prompt injection planning."
+    },
     ranking: {
       type: "string",
       description: "Ranking profile for context ordering",
@@ -3978,7 +4078,9 @@ var COMPILE_CONTEXT = {
       recentEvidence: "array \u2014 recent evidence ranked for this query",
       contradictions: "array \u2014 unresolved contradiction records",
       relatedEntities: "array | undefined \u2014 ranked ontological entities in scope",
-      contextNarrative: "array \u2014 guidance for prompt assembly",
+      contextNarrative: "array \u2014 ordered synthesis blocks with kind/text, starting with executive_summary and canonical narrative blocks before raw objects",
+      retrievalReceipt: "object \u2014 candidateCounts, coverageWarning, narrativeCoverage, synthesisLints, and suggestedNextActions",
+      narrativeCoverage: "object \u2014 recordsSynthesized, recordsNamed, recordsOmitted, and blocksEmitted for the narrative",
       injectionPolicy: "object \u2014 token-budgeted section selections",
       diagnostics: "object \u2014 scoring and utilization telemetry"
     }
@@ -4633,6 +4735,7 @@ var MCP_TOOL_CONTRACTS = {
   update_worktree_metadata: UPDATE_WORKTREE_METADATA,
   identity_whoami: IDENTITY_WHOAMI,
   resolve_interactive_principal: RESOLVE_INTERACTIVE_PRINCIPAL,
+  lucern_orient: LUCERN_ORIENT,
   compile_context: COMPILE_CONTEXT,
   record_scope_learning: RECORD_SCOPE_LEARNING,
   pipeline_snapshot: PIPELINE_SNAPSHOT,
@@ -10348,6 +10451,20 @@ GRAPH_INTELLIGENCE_QUERIES.map((query) => {
 var WEBHOOK_MAX_ATTEMPTS = 5;
 var WEBHOOK_RETRY_DELAYS_MS = [1e3, 5e3, 3e4, 3e5];
 
+// ../contracts/src/ids.contract.ts
+var PREFIXED_ID_PATTERN = /^([a-z][a-z0-9]*)_(.+)$/;
+function decodePrefixedId(id) {
+  const normalized = id.trim();
+  const match = PREFIXED_ID_PATTERN.exec(normalized);
+  if (!match) {
+    throw new Error(`Invalid prefixed ID: ${id}`);
+  }
+  return {
+    prefix: match[1],
+    value: match[2]
+  };
+}
+
 // ../contracts/src/schema-helpers/spine/tables/epistemicNodes.ts
 var NODE_TYPES = [
   "decision",
@@ -11463,6 +11580,23 @@ function defineProjection(def) {
 
 // ../contracts/src/projections/create-evidence.projection.ts
 var jsonRecordSchema = z.record(z.unknown());
+var evidenceRelationSchema = z.enum(["supports", "contradicts"]);
+var evidenceRelationAliasSchema = z.enum([
+  "supports",
+  "contradicts",
+  "supporting",
+  "contradicting"
+]);
+var beliefRelationSchema = z.object({
+  beliefId: z.string().optional(),
+  beliefNodeId: z.string().optional(),
+  targetId: z.string().optional(),
+  relation: evidenceRelationAliasSchema.optional(),
+  evidenceRelation: evidenceRelationSchema.optional(),
+  confidence: z.number().optional(),
+  weight: z.number().optional(),
+  rationale: z.string().optional()
+});
 var createEvidenceInputSchemaBase = z.object({
   projectId: z.string().optional(),
   topicId: z.string().optional(),
@@ -11484,7 +11618,8 @@ var createEvidenceInputSchemaBase = z.object({
   targetId: z.string().optional(),
   targetNodeId: z.string().optional(),
   linkedBeliefNodeId: z.string().optional(),
-  evidenceRelation: z.enum(["supports", "contradicts"]).optional(),
+  evidenceRelation: evidenceRelationSchema.optional(),
+  beliefRelations: z.array(beliefRelationSchema).optional(),
   confidence: z.number().optional(),
   weight: z.number().optional(),
   reasoning: z.string().optional(),
@@ -11510,15 +11645,103 @@ function isRecord(value) {
 function recordValue(value) {
   return isRecord(value) ? value : {};
 }
+function normalizeTopicIdForKernel(topicId) {
+  const normalized = topicId?.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  try {
+    const decoded = decodePrefixedId(normalized);
+    return decoded.prefix === "top" ? decoded.value : normalized;
+  } catch {
+    return normalized;
+  }
+}
+function normalizeWorktreeId(value) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  if (normalized.startsWith("wt_")) {
+    return normalized.slice("wt_".length);
+  }
+  return normalized;
+}
+function targetKind(targetId) {
+  const normalized = targetId?.trim();
+  if (!normalized) {
+    return "unknown";
+  }
+  if (normalized.startsWith("wt_") || /^tn[a-z0-9]+$/i.test(normalized)) {
+    return "worktree";
+  }
+  if (normalized.startsWith("que_")) {
+    return "question";
+  }
+  if (normalized.startsWith("bel_")) {
+    return "belief";
+  }
+  return "unknown";
+}
+function normalizeRelation(value, weight) {
+  if (value === "supports" || value === "supporting") {
+    return "supports";
+  }
+  if (value === "contradicts" || value === "contradicting") {
+    return "contradicts";
+  }
+  if (weight === void 0) {
+    return void 0;
+  }
+  return weight < 0 ? "contradicts" : "supports";
+}
+function normalizeConfidence(confidence, weight) {
+  if (confidence !== void 0) {
+    return Math.min(1, Math.max(0, confidence));
+  }
+  if (weight === void 0) {
+    return void 0;
+  }
+  return Math.min(1, Math.max(0, Math.abs(weight)));
+}
+function normalizeBeliefRelation(relation) {
+  const beliefNodeId = relation.beliefNodeId ?? relation.beliefId ?? relation.targetId;
+  if (!beliefNodeId) {
+    return void 0;
+  }
+  const weight = typeof relation.weight === "number" ? relation.weight : void 0;
+  const evidenceRelation = normalizeRelation(
+    relation.evidenceRelation ?? relation.relation,
+    weight
+  );
+  if (!evidenceRelation) {
+    return void 0;
+  }
+  return compactRecord({
+    beliefNodeId,
+    relation: evidenceRelation,
+    confidence: normalizeConfidence(relation.confidence, weight),
+    rationale: relation.rationale
+  });
+}
 var createEvidenceProjection = defineProjection({
   contractName: "create_evidence",
   inputSchema: createEvidenceInputSchema,
   project: (input) => {
     const text = input.text ?? input.canonicalText;
     const weight = typeof input.weight === "number" ? input.weight : void 0;
+    const target = input.targetId ?? input.targetNodeId;
+    const kind = targetKind(target);
+    const linkedWorktreeId = kind === "worktree" ? normalizeWorktreeId(target) : void 0;
+    const linkedBeliefNodeId = input.linkedBeliefNodeId ?? (kind === "belief" || kind === "unknown" ? input.targetNodeId ?? input.targetId : void 0);
+    const evidenceRelation = linkedBeliefNodeId ? normalizeRelation(input.evidenceRelation, weight) : void 0;
+    const confidence = evidenceRelation ? normalizeConfidence(input.confidence, weight) : void 0;
+    const beliefRelations = input.beliefRelations?.map(normalizeBeliefRelation).filter(
+      (relation) => relation !== void 0
+    );
     return compactRecord({
       projectId: input.projectId,
-      topicId: input.topicId,
+      topicId: normalizeTopicIdForKernel(input.topicId),
       text,
       title: input.title ?? text,
       content: input.content ?? text,
@@ -11537,13 +11760,16 @@ var createEvidenceProjection = defineProjection({
         source: input.source,
         targetId: input.targetId,
         targetNodeId: input.targetNodeId,
+        targetKind: kind === "unknown" ? void 0 : kind,
+        linkedWorktreeId,
         weight,
         reasoning: input.reasoning,
         rationale: input.rationale
       }),
-      linkedBeliefNodeId: input.linkedBeliefNodeId ?? input.targetNodeId ?? input.targetId,
-      evidenceRelation: input.evidenceRelation ?? (weight === void 0 ? void 0 : weight < 0 ? "contradicts" : "supports"),
-      confidence: input.confidence ?? (weight === void 0 ? void 0 : Math.min(1, Math.max(0, Math.abs(weight)))),
+      linkedBeliefNodeId,
+      evidenceRelation,
+      confidence,
+      beliefRelations: beliefRelations && beliefRelations.length > 0 ? beliefRelations : void 0,
       rationale: input.rationale,
       trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
     });
@@ -11572,6 +11798,16 @@ var createEvidenceProjection = defineProjection({
         v.literal("contradicts")
       )
     ),
+    beliefRelations: v.optional(
+      v.array(
+        v.object({
+          beliefNodeId: v.string(),
+          relation: v.union(v.literal("supports"), v.literal("contradicts")),
+          confidence: v.optional(v.number()),
+          rationale: v.optional(v.string())
+        })
+      )
+    ),
     confidence: v.optional(v.number()),
     rationale: v.string(),
     trustedBypassAccessCheck: v.optional(v.boolean())
@@ -11805,6 +12041,12 @@ var internalSystem = {
   mcp: "internal",
   cli: "internal"
 };
+var internalSdkRestOnly = {
+  sdk: "internal",
+  rest: "internal",
+  mcp: "none",
+  cli: "none"
+};
 var publicWithInternalMcp = {
   sdk: "public",
   rest: "public",
@@ -11844,6 +12086,7 @@ function entries(names, surfaceClass, surfaceIntent, surfaces, rationale) {
   );
 }
 var MCP_CORE_OPERATION_NAMES = [
+  "lucern_orient",
   "compile_context",
   "identity_whoami",
   "resolve_interactive_principal",
@@ -11853,7 +12096,6 @@ var MCP_CORE_OPERATION_NAMES = [
   "get_belief",
   "list_beliefs",
   "refine_belief",
-  "modulate_confidence",
   "fork_belief",
   "archive_belief",
   "search_beliefs",
@@ -12121,6 +12363,13 @@ var LUCERN_OPERATION_MANIFEST = {
     internalSystem,
     "Lucern system/background operation. Available to platform code paths, hidden from public MCP discovery."
   ),
+  modulate_confidence: {
+    name: "modulate_confidence",
+    surfaceClass: "platform_internal",
+    surfaceIntent: "system",
+    surfaces: internalSdkRestOnly,
+    rationale: "Internal SL ledger append primitive. Public callers attach evidence or contradiction relations; confidence is derived algorithmically."
+  },
   ...entries(
     LEGACY_COMPAT_OPERATION_NAMES,
     "legacy_compat",
@@ -12472,6 +12721,14 @@ var observationContextArgs = z.object({
   limit: z.number().optional().describe("Maximum observations to return."),
   status: z.string().optional().describe("Observation status filter.")
 });
+var lucernOrientArgs = z.object({
+  audience: z.enum(["agent", "human", "operator", "developer"]).optional().describe("Audience for the orientation primer."),
+  depth: z.enum(["quick", "standard", "deep"]).optional().describe("How much orientation detail to include."),
+  situation: z.string().optional().describe("Optional task or query context for suggested next calls."),
+  includeExamples: z.boolean().optional().describe("Include concrete tool-call examples."),
+  includeToolMap: z.boolean().optional().describe("Include situation-to-tool routing guidance."),
+  includeFuture: z.boolean().optional().describe("Include future training and pedagogy capabilities.")
+});
 function isRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -12499,6 +12756,20 @@ var observationInput = (input, context) => withUserId(
   context
 );
 var contextContracts = [
+  surfaceContract({
+    name: "lucern_orient",
+    kind: "query",
+    domain: "context",
+    surfaceClass: "platform_public",
+    path: "/context/orient",
+    sdkNamespace: "context",
+    sdkMethod: "lucernOrient",
+    summary: "Return the canonical Lucern operator orientation primer.",
+    gateway: {
+      handler: "context.lucernOrient"
+    },
+    args: lucernOrientArgs
+  }),
   surfaceContract({
     name: "compile_context",
     kind: "query",
@@ -12802,11 +13073,11 @@ var beliefsContracts = [
     name: "modulate_confidence",
     kind: "mutation",
     domain: "beliefs",
-    surfaceClass: "platform_public",
+    surfaceClass: "platform_internal",
     path: "/beliefs/confidence",
     sdkNamespace: "beliefs",
     sdkMethod: "modulateConfidence",
-    summary: "Append a belief confidence modulation.",
+    summary: "Internal SL ledger append. Public callers should attach evidence or contradiction relations instead.",
     convex: {
       module: "beliefs",
       functionName: "modulateConfidence",
@@ -12912,15 +13183,28 @@ var beliefsContracts = [
   })
 ];
 var jsonRecordSchema4 = z.record(z.unknown());
-var evidenceRelationSchema = z.enum(["supports", "contradicts"]);
+var evidenceRelationSchema2 = z.enum(["supports", "contradicts"]);
+var beliefRelationSchema2 = z.object({
+  beliefId: z.string().optional().describe("Belief ID this evidence bears on."),
+  beliefNodeId: z.string().optional().describe("Belief node ID this evidence bears on."),
+  targetId: z.string().optional().describe("Belief target ID alias for beliefId/beliefNodeId."),
+  relation: z.enum(["supports", "contradicts", "supporting", "contradicting"]).optional().describe("Relation alias for how the evidence bears on the belief."),
+  evidenceRelation: evidenceRelationSchema2.optional().describe("Canonical relation: supports or contradicts."),
+  confidence: z.number().optional().describe("Confidence in this evidence-to-belief relation."),
+  weight: z.number().optional().describe("Support weight from -1.0 to +1.0 for this belief."),
+  rationale: z.string().optional().describe("Why this relation exists.")
+});
 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."),
+  targetId: z.string().optional().describe("Belief, question, or worktree identifier to link or preserve on the evidence record."),
   linkedBeliefNodeId: z.string().optional().describe("Belief node this evidence bears on."),
-  evidenceRelation: evidenceRelationSchema.optional().describe("How the evidence relates to the linked belief."),
+  evidenceRelation: evidenceRelationSchema2.optional().describe("How the evidence relates to the linked belief."),
+  beliefRelations: z.array(beliefRelationSchema2).optional().describe(
+    "Additional belief relations for one evidence record. Use when the same evidence supports or contradicts multiple beliefs."
+  ),
   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."),
@@ -12951,11 +13235,6 @@ var addEvidenceArgs = z.object({
   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,
-  nodeId: input.nodeId ?? input.id ?? input.evidenceId
-});
 var createEvidenceInput = (input, context) => {
   const parsed = createEvidenceProjection.inputSchema.safeParse(input);
   if (!parsed.success) {
@@ -12968,6 +13247,30 @@ var createEvidenceInput = (input, context) => {
     context
   );
 };
+function relationWeight(input) {
+  if (typeof input.weight === "number") {
+    return input.weight;
+  }
+  const confidence = typeof input.confidence === "number" ? Math.max(0, Math.min(1, input.confidence)) : 0.7;
+  const relation = String(
+    input.evidenceRelation ?? input.relation ?? input.type ?? ""
+  );
+  return relation === "contradicts" || relation === "contradicting" ? -confidence : confidence;
+}
+var linkEvidenceToBeliefInput = (input, context) => {
+  const weight = relationWeight(input);
+  return withUserId(
+    compactRecord4({
+      beliefNodeId: input.beliefNodeId ?? input.beliefId ?? input.targetId,
+      insightId: input.insightId ?? input.evidenceNodeId ?? input.evidenceId,
+      type: weight < 0 ? "contradicting" : "supporting",
+      confidence: Math.min(1, Math.abs(weight)),
+      rationale: input.rationale ?? input.context,
+      trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
+    }),
+    context
+  );
+};
 var linkEvidenceToBeliefEdgeInput = (input, context) => withCreatedBy(
   compactRecord4({
     fromNodeId: input.insightId ?? input.evidenceNodeId ?? input.evidenceId,
@@ -13069,11 +13372,8 @@ var evidenceContracts = [
     sdkNamespace: "evidence",
     sdkMethod: "getEvidence",
     summary: "Get evidence.",
-    convex: {
-      module: "evidence",
-      functionName: "getById",
-      kind: "query",
-      inputProjection: evidenceIdInput
+    gateway: {
+      handler: "evidence.get"
     }
   }),
   surfaceContract({
@@ -13099,17 +13399,8 @@ var evidenceContracts = [
     sdkNamespace: "evidence",
     sdkMethod: "searchEvidence",
     summary: "Search evidence.",
-    convex: {
-      module: "nodes",
-      functionName: "search",
-      kind: "query",
-      inputProjection: (input) => compactRecord4({
-        searchQuery: input.searchQuery ?? input.q ?? input.query,
-        projectId: input.projectId,
-        topicId: input.topicId,
-        nodeType: "evidence",
-        limit: input.limit
-      })
+    gateway: {
+      handler: "evidence.search"
     }
   }),
   surfaceContract({
@@ -13122,10 +13413,10 @@ var evidenceContracts = [
     sdkMethod: "linkEvidenceToBelief",
     summary: "Link evidence to a belief.",
     convex: {
-      module: "edges",
-      functionName: "create",
+      module: "beliefs",
+      functionName: "linkEvidence",
       kind: "mutation",
-      inputProjection: linkEvidenceToBeliefEdgeInput
+      inputProjection: linkEvidenceToBeliefInput
     }
   }),
   surfaceContract({
@@ -13697,10 +13988,8 @@ var topicsContracts = [
     sdkNamespace: "topics",
     sdkMethod: "getTopicGraphSpine",
     summary: "Verify topic nodes and parent-child graph edges.",
-    convex: {
-      module: "topics",
-      functionName: "getTopicGraphSpine",
-      kind: "query"
+    gateway: {
+      handler: "topics.graphSpine"
     },
     args: getTopicGraphSpineArgs
   })
@@ -15407,10 +15696,8 @@ var graphContracts = [
     sdkNamespace: "graphAnalysis",
     sdkMethod: "listGraphIntelligenceQueries",
     summary: "List Graph Intelligence query catalog entries.",
-    convex: {
-      module: "contextCompiler",
-      functionName: "listGraphIntelligenceQueries",
-      kind: "query"
+    gateway: {
+      handler: "graph.listIntelligenceQueries"
     },
     args: graphIntelligenceCatalogArgs
   }),