@lucern/mcp 0.3.0-alpha.0 → 0.3.0-alpha.1

package/dist/runtime.js

@@ -2,7 +2,8 @@ import * as fs from 'fs';
 import * as path2 from 'path';
 import { basename, extname } from 'path';
 import { z } from 'zod';
-import { internal, components, api as api$1 } from '@lucern/reasoning-kernel/_generated/api';
+import { v } from 'convex/values';
+import { internal, components, api as api$1 } from '@lucern/reasoning-kernel/adapters/convex';
 import 'stream';
 import { AsyncLocalStorage } from 'async_hooks';
 import { ConvexHttpClient } from 'convex/browser';
@@ -609,6 +610,28 @@ defineTable({
     { kind: "index", name: "by_createdAt", columns: ["createdAt"] }
   ]
 });
+defineTable({
+  name: "neo4jSyncQueue",
+  component: "kernel",
+  category: "infra",
+  shape: z.object({
+    "entityType": z.enum(["node", "edge"]),
+    "entityId": z.string(),
+    "operation": z.enum(["upsert", "delete"]),
+    "attempts": z.number(),
+    "maxAttempts": z.number(),
+    "lastAttemptAt": z.number().optional(),
+    "lastError": z.string().optional(),
+    "status": z.enum(["pending", "in_progress", "failed", "succeeded"]),
+    "createdAt": z.number(),
+    "updatedAt": z.number()
+  }),
+  indices: [
+    { kind: "index", name: "by_status", columns: ["status"] },
+    { kind: "index", name: "by_entity", columns: ["entityType", "entityId"] },
+    { kind: "index", name: "by_status_attempts", columns: ["status", "attempts"] }
+  ]
+});
 defineTable({
   name: "backgroundJobRuns",
   component: "kernel",
@@ -678,9 +701,9 @@ defineTable({
   category: "epistemic",
   shape: z.object({
     "beliefId": z.string(),
-    "belief": z.number().optional(),
-    "disbelief": z.number().optional(),
-    "uncertainty": z.number().optional(),
+    "belief": z.number(),
+    "disbelief": z.number(),
+    "uncertainty": z.number(),
     "baseRate": z.number(),
     "slOperator": z.string().optional(),
     "confidence": z.number(),
@@ -689,10 +712,12 @@ defineTable({
     "certainty": z.number().optional(),
     "assessedAt": z.number(),
     "assessedBy": z.string(),
-    "trigger": z.enum(["initial", "evidence_added", "evidence_removed", "contradiction_detected", "contradiction_resolved", "manual", "decay", "propagation", "agent_assessment", "worktree_outcome", "worktree_completed", "fusion", "discount", "deduction", "backfill_synthetic"]),
+    "trigger": z.enum(["initial", "evidence_added", "evidence_removed", "contradiction_detected", "contradiction_resolved", "propagation", "agent_assessment", "worktree_outcome", "worktree_completed", "fusion", "discount", "deduction", "backfill_synthetic"]),
     "rationale": z.string().optional(),
     "triggeringEvidenceId": z.string().optional(),
     "triggeringEvidenceIds": z.array(z.string()).optional(),
+    "triggeringQuestionId": z.string().optional(),
+    "triggeringAnswerId": z.string().optional(),
     "triggeringContradictionId": idOf("contradictions").optional(),
     "triggeringWorktreeId": z.string().optional(),
     "triggeringAgentId": z.string().optional(),
@@ -1375,7 +1400,7 @@ defineTable({
     "credentialRef": z.string(),
     "tenantId": idOf("tenants"),
     "target": z.enum(["kernelDeployment", "appDeployment"]),
-    "environment": z.enum(["dev", "prod"]),
+    "environment": z.enum(["dev", "staging", "prod"]),
     "encryptedDeployKey": z.string(),
     "encryptionVersion": z.string(),
     "keyFingerprint": z.string(),
@@ -4044,13 +4069,13 @@ defineTable({
     "rationale": z.string().optional(),
     "confidenceImpact": z.enum(["high", "medium", "low"]).optional(),
     "hypothesis": z.string().optional(),
-    "executionOrder": z.number().optional(),
     "dependsOn": z.array(idOf("worktrees")).optional(),
     "blocks": z.array(idOf("worktrees")).optional(),
     "gate": z.string().optional(),
-    "track": z.string().optional(),
-    "trackPosition": z.number().optional(),
-    "executionBand": z.number().optional(),
+    "campaign": z.number().optional(),
+    "lane": z.string().optional(),
+    "laneOrderInCampaign": z.number().optional(),
+    "orderInLane": z.number().optional(),
     "startDate": z.number(),
     "endDate": z.number(),
     "durationWeeks": z.number(),
@@ -4298,10 +4323,469 @@ defineTable({
     { kind: "index", name: "by_topicId_index", columns: ["topicId", "index"] },
     { kind: "index", name: "by_worktreeType", columns: ["topicId", "worktreeType"] },
     { kind: "index", name: "by_topicId_priority", columns: ["topicId", "priority"] },
+    { kind: "index", name: "by_topicId_campaign_lane_order", columns: ["topicId", "campaign", "laneOrderInCampaign", "orderInLane"] },
+    { kind: "index", name: "by_topicId_lane_order", columns: ["topicId", "lane", "orderInLane"] },
     { kind: "index", name: "by_topicId_branch", columns: ["topicId", "targetBranch"] },
     { kind: "index", name: "by_topicId_scope", columns: ["topicId", "worktreeScope"] }
   ]
 });
+z.object({
+  manifestVersion: z.string(),
+  componentName: z.enum(["kernel", "identity"]),
+  tier: z.enum(["K", "I"]),
+  packageVersion: z.string(),
+  tables: z.array(
+    z.object({
+      name: z.string(),
+      fields: z.array(
+        z.object({
+          name: z.string(),
+          type: z.string(),
+          optional: z.boolean(),
+          validator: z.string().optional()
+        })
+      )
+    })
+  )
+});
+var SL_EPSILON = 1e-9;
+z.object({
+  belief: z.number(),
+  disbelief: z.number(),
+  uncertainty: z.number(),
+  baseRate: z.number()
+}).refine(
+  (o) => Math.abs(o.belief + o.disbelief + o.uncertainty - 1) < SL_EPSILON,
+  {
+    message: "SL invariant b+d+u=1 violated at API boundary"
+  }
+);
+var EpistemicNodeTypeSchema = z.enum([
+  "belief",
+  "evidence",
+  "question",
+  "answer",
+  "topic",
+  "edge",
+  "ontology",
+  "lens",
+  "contradiction"
+]);
+var GraphRefSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("epistemic_node"),
+    nodeId: z.string(),
+    nodeType: EpistemicNodeTypeSchema
+  }),
+  z.object({
+    kind: z.literal("external_belief"),
+    ref: z.object({
+      tenantId: z.string(),
+      beliefId: z.string()
+    })
+  })
+]);
+var graphRefKind = z.enum(["epistemic_node", "external_belief"]);
+var EdgePolicyEntrySchema = z.object({
+  edgeType: z.string(),
+  fromKinds: z.array(graphRefKind),
+  fromNodeTypes: z.array(EpistemicNodeTypeSchema).optional(),
+  toKinds: z.array(graphRefKind),
+  toNodeTypes: z.array(EpistemicNodeTypeSchema).optional(),
+  description: z.string()
+});
+z.object({
+  manifestVersion: z.literal("1.0.0"),
+  policies: z.array(EdgePolicyEntrySchema)
+});
+function findEdgePolicy(manifest, edgeType) {
+  return manifest.policies.find((policy) => policy.edgeType === edgeType);
+}
+function nodeTypeAllowed(allowed, ref) {
+  return ref.kind !== "epistemic_node" || !allowed || allowed.includes(ref.nodeType);
+}
+function assertEdgePolicyAllowed(manifest, edgeType, from, to) {
+  const policy = findEdgePolicy(manifest, edgeType);
+  const allowed = Boolean(policy) && policy.fromKinds.includes(from.kind) && policy.toKinds.includes(to.kind) && nodeTypeAllowed(policy.fromNodeTypes, from) && nodeTypeAllowed(policy.toNodeTypes, to);
+  if (!allowed) {
+    const error = new Error(
+      `Edge policy violation for ${edgeType}: ${from.kind} -> ${to.kind}`
+    );
+    error.code = "POLICY_VIOLATION";
+    error.details = { code: "POLICY_VIOLATION", edgeType, from, to };
+    throw error;
+  }
+}
+
+// ../contracts/src/manifests/edge-policy-manifest.data.ts
+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."
+    }
+  ]
+};
+z.object({
+  manifestVersion: z.literal("1.0.0"),
+  rules: z.array(
+    z.object({
+      invariant: z.string(),
+      description: z.string(),
+      checker: z.enum(["ast", "manifest", "runtime"]),
+      severity: z.enum(["block_publish", "block_pr", "warn"])
+    })
+  )
+});
+
+// ../contracts/src/projections/projection-dsl.ts
+function defineProjection(def) {
+  return def;
+}
+
+// ../contracts/src/projections/create-evidence.projection.ts
+var jsonRecordSchema = z.record(z.unknown());
+var createEvidenceInputSchemaBase = z.object({
+  projectId: z.string().optional(),
+  topicId: z.string().optional(),
+  text: z.string().optional(),
+  canonicalText: z.string().optional(),
+  title: z.string().optional(),
+  content: z.string().optional(),
+  contentType: z.string().optional(),
+  kind: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  source: z.string().optional(),
+  sourceUrl: z.string().optional(),
+  sourceType: z.string().optional(),
+  externalSourceType: z.string().optional(),
+  sourceQuestionId: z.string().optional(),
+  methodology: z.string().optional(),
+  informationAsymmetry: z.string().optional(),
+  sourceDescription: z.string().optional(),
+  targetId: z.string().optional(),
+  targetNodeId: z.string().optional(),
+  linkedBeliefNodeId: z.string().optional(),
+  evidenceRelation: z.enum(["supports", "contradicts", "neutral"]).optional(),
+  confidence: z.number().optional(),
+  weight: z.number().optional(),
+  reasoning: z.string().optional(),
+  rationale: z.string(),
+  metadata: jsonRecordSchema.optional(),
+  trustedBypassAccessCheck: z.boolean().optional()
+}).passthrough();
+var createEvidenceInputSchema = createEvidenceInputSchemaBase.refine(
+  (input) => Boolean(input.text ?? input.canonicalText),
+  {
+    message: "create_evidence requires text",
+    path: ["text"]
+  }
+);
+function compactRecord(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => value !== void 0)
+  );
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+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;
+    return compactRecord({
+      projectId: input.projectId,
+      topicId: input.topicId,
+      text,
+      title: input.title ?? text,
+      content: input.content ?? text,
+      contentType: input.contentType,
+      kind: input.kind,
+      tags: input.tags,
+      sourceType: input.sourceType,
+      externalSourceType: input.externalSourceType,
+      sourceUrl: input.sourceUrl ?? input.source,
+      sourceQuestionId: input.sourceQuestionId,
+      methodology: input.methodology,
+      informationAsymmetry: input.informationAsymmetry,
+      sourceDescription: input.sourceDescription,
+      metadata: compactRecord({
+        ...recordValue(input.metadata),
+        source: input.source,
+        targetId: input.targetId,
+        targetNodeId: input.targetNodeId,
+        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)))),
+      rationale: input.rationale,
+      trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
+    });
+  },
+  convexArgsValidator: v.object({
+    projectId: v.optional(v.string()),
+    topicId: v.optional(v.string()),
+    text: v.string(),
+    title: v.optional(v.string()),
+    content: v.optional(v.string()),
+    contentType: v.optional(v.string()),
+    kind: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+    sourceType: v.optional(v.string()),
+    externalSourceType: v.optional(v.string()),
+    sourceUrl: v.optional(v.string()),
+    sourceQuestionId: v.optional(v.string()),
+    methodology: v.optional(v.string()),
+    informationAsymmetry: v.optional(v.string()),
+    sourceDescription: v.optional(v.string()),
+    metadata: v.optional(v.record(v.string(), v.any())),
+    linkedBeliefNodeId: v.optional(v.string()),
+    evidenceRelation: v.optional(
+      v.union(
+        v.literal("supports"),
+        v.literal("contradicts"),
+        v.literal("neutral")
+      )
+    ),
+    confidence: v.optional(v.number()),
+    rationale: v.string(),
+    trustedBypassAccessCheck: v.optional(v.boolean())
+  })
+});
+var beliefStatusSchema = z.enum(["active", "superseded", "archived", "unscored", "scored"]).optional().describe("Filter by belief lifecycle or scoring status");
+var listBeliefsInputSchema = z.object({
+  topicId: z.string().describe("Topic scope"),
+  worktreeId: z.string().optional().describe("Filter to worktree scope"),
+  status: beliefStatusSchema,
+  minConfidence: z.number().optional().describe("Minimum confidence threshold"),
+  limit: z.number().optional().describe("Maximum results"),
+  includeEdgeAssociated: z.boolean().optional().describe("Include beliefs associated to the topic through edges")
+});
+function kernelStatus(status) {
+  return status === "active" || status === "superseded" || status === "archived" ? status : void 0;
+}
+function compactRecord2(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => value !== void 0)
+  );
+}
+var listBeliefsProjection = defineProjection({
+  contractName: "list_beliefs",
+  inputSchema: listBeliefsInputSchema,
+  project: (input) => compactRecord2({
+    topicId: input.topicId,
+    status: kernelStatus(input.status),
+    limit: input.limit,
+    includeEdgeAssociated: input.includeEdgeAssociated
+  }),
+  convexArgsValidator: v.object({
+    topicId: v.string(),
+    status: v.optional(
+      v.union(
+        v.literal("active"),
+        v.literal("superseded"),
+        v.literal("archived")
+      )
+    ),
+    limit: v.optional(v.number()),
+    includeEdgeAssociated: v.optional(v.boolean())
+  })
+});
+var taskStatusSchema = z.enum(["todo", "in_progress", "blocked", "done"]).optional().describe("Filter by task status");
+var listTasksInputSchema = z.object({
+  topicId: z.string().describe("Topic scope"),
+  worktreeId: z.string().optional().describe("Alias for linkedWorktreeId"),
+  linkedWorktreeId: z.string().optional().describe("Filter to tasks linked to this worktree"),
+  status: taskStatusSchema,
+  limit: z.number().optional().describe("Maximum results")
+});
+function compactRecord3(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => value !== void 0)
+  );
+}
+var listTasksProjection = defineProjection({
+  contractName: "list_tasks",
+  inputSchema: listTasksInputSchema,
+  project: (input) => compactRecord3({
+    topicId: input.topicId,
+    status: input.status,
+    userId: void 0,
+    limit: input.limit,
+    linkedWorktreeId: input.linkedWorktreeId ?? input.worktreeId
+  }),
+  convexArgsValidator: v.object({
+    topicId: v.string(),
+    status: v.optional(
+      v.union(
+        v.literal("todo"),
+        v.literal("in_progress"),
+        v.literal("blocked"),
+        v.literal("done")
+      )
+    ),
+    limit: v.optional(v.number()),
+    linkedWorktreeId: v.optional(v.string())
+  })
+});
+var confidenceTriggerSchema = z.enum([
+  "evidence_added",
+  "evidence_removed",
+  "contradiction_resolved",
+  "agent_assessment",
+  "worktree_outcome",
+  "worktree_completed",
+  "contradiction_detected",
+  "answer_recorded",
+  "fusion",
+  "discount",
+  "deduction",
+  "backfill_synthetic"
+]);
+var provenanceSchema = z.object({
+  evidence: z.string().optional(),
+  question: z.string().optional(),
+  answer: z.string().optional(),
+  contradiction: z.string().optional(),
+  worktree: z.string().optional()
+});
+var slOpinionProjectionSchema = z.object({
+  belief: z.number(),
+  disbelief: z.number(),
+  uncertainty: z.number(),
+  baseRate: z.number()
+});
+var modulateConfidenceInputObjectSchema = z.object({
+  nodeId: z.string().optional(),
+  beliefNodeId: z.string().optional(),
+  worktreeId: z.string().optional(),
+  opinion: slOpinionProjectionSchema.optional(),
+  belief: z.number().optional(),
+  disbelief: z.number().optional(),
+  uncertainty: z.number().optional(),
+  baseRate: z.number().optional(),
+  trigger: confidenceTriggerSchema,
+  provenance: provenanceSchema.optional(),
+  triggeringEvidenceId: z.string().optional(),
+  triggeringQuestionId: z.string().optional(),
+  triggeringAnswerId: z.string().optional(),
+  triggeringContradictionId: z.string().optional(),
+  triggeringWorktreeId: z.string().optional(),
+  rationale: z.string(),
+  trustedBypassAccessCheck: z.boolean().optional()
+});
+var modulateConfidenceInputSchema = modulateConfidenceInputObjectSchema.superRefine((input, ctx) => {
+  if (hasProvenance(input)) {
+    return;
+  }
+  ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    message: "modulate_confidence requires evidence, question, answer, contradiction, or worktree provenance",
+    path: ["provenance"]
+  });
+});
+var modulateConfidenceProjection = defineProjection({
+  contractName: "modulate_confidence",
+  inputSchema: modulateConfidenceInputSchema,
+  project: (input) => {
+    const nodeId = input.beliefNodeId ?? input.nodeId;
+    if (!nodeId) {
+      throw new Error("modulate_confidence requires beliefNodeId or nodeId");
+    }
+    const opinion = input.opinion ?? {
+      belief: requireNumber(input.belief, "belief"),
+      disbelief: requireNumber(input.disbelief, "disbelief"),
+      uncertainty: requireNumber(input.uncertainty, "uncertainty"),
+      baseRate: requireNumber(input.baseRate, "baseRate")
+    };
+    assertProvenance(input);
+    return {
+      nodeId,
+      worktreeId: input.worktreeId,
+      belief: opinion.belief,
+      disbelief: opinion.disbelief,
+      uncertainty: opinion.uncertainty,
+      baseRate: opinion.baseRate,
+      trigger: input.trigger === "answer_recorded" ? "agent_assessment" : input.trigger,
+      triggeringEvidenceId: input.provenance?.evidence ?? input.triggeringEvidenceId,
+      triggeringQuestionId: input.provenance?.question ?? input.triggeringQuestionId,
+      triggeringAnswerId: input.provenance?.answer ?? input.triggeringAnswerId,
+      triggeringContradictionId: input.provenance?.contradiction ?? input.triggeringContradictionId,
+      triggeringWorktreeId: input.provenance?.worktree ?? input.triggeringWorktreeId,
+      rationale: input.rationale,
+      trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
+    };
+  },
+  convexArgsValidator: v.object({
+    nodeId: v.string(),
+    worktreeId: v.optional(v.string()),
+    belief: v.number(),
+    disbelief: v.number(),
+    uncertainty: v.number(),
+    baseRate: v.number(),
+    trigger: v.union(
+      v.literal("evidence_added"),
+      v.literal("evidence_removed"),
+      v.literal("worktree_completed"),
+      v.literal("contradiction_detected"),
+      v.literal("contradiction_resolved"),
+      v.literal("agent_assessment"),
+      v.literal("worktree_outcome"),
+      v.literal("fusion"),
+      v.literal("discount"),
+      v.literal("deduction"),
+      v.literal("backfill_synthetic")
+    ),
+    triggeringEvidenceId: v.optional(v.string()),
+    triggeringQuestionId: v.optional(v.string()),
+    triggeringAnswerId: v.optional(v.string()),
+    triggeringContradictionId: v.optional(v.string()),
+    triggeringWorktreeId: v.optional(v.string()),
+    rationale: v.string(),
+    trustedBypassAccessCheck: v.optional(v.boolean())
+  })
+});
+function requireNumber(value, field) {
+  if (value === void 0) {
+    throw new Error(`modulate_confidence requires ${field}`);
+  }
+  return value;
+}
+function assertProvenance(input) {
+  if (!hasProvenance(input)) {
+    throw new Error(
+      "modulate_confidence requires evidence, question, answer, contradiction, or worktree provenance"
+    );
+  }
+}
+function hasProvenance(input) {
+  return input.trigger === "backfill_synthetic" || Boolean(input.provenance && Object.values(input.provenance).some(Boolean)) || Boolean(input.triggeringEvidenceId) || Boolean(input.triggeringQuestionId) || Boolean(input.triggeringAnswerId) || Boolean(input.triggeringContradictionId) || Boolean(input.triggeringWorktreeId);
+}
 
 // ../contracts/src/lens-filter.contract.ts
 function isLensFilterCriteria(value) {
@@ -4383,7 +4867,7 @@ var LENS_PERSPECTIVE_TYPES = [
 // ../contracts/src/tool-contracts.ts
 var CREATE_BELIEF = {
   name: "create_belief",
-  description: "Commit a new belief (knowledge unit) to the reasoning graph. Like `git commit` \u2014 creates an atomic, traceable knowledge object with a mandatory prior. Creation stores the vacuous opinion `(0, 0, 1, a)`; use modulate_confidence to record the first evidential update.",
+  description: "Commit a new belief (knowledge unit) to the reasoning graph. Like `git commit` \u2014 creates an atomic, traceable knowledge object with a prior. Creation stores the vacuous opinion `(0, 0, 1, a)`; use modulate_confidence to record the first evidential update.",
   parameters: {
     canonicalText: {
       type: "string",
@@ -4395,7 +4879,7 @@ var CREATE_BELIEF = {
     },
     baseRate: {
       type: "number",
-      description: "Required prior probability used to seed the vacuous opinion `(0, 0, 1, a)` at creation time."
+      description: "Prior probability used to seed the vacuous opinion `(0, 0, 1, a)` at creation time. Defaults to 0.5 when omitted."
     },
     beliefType: {
       type: "string",
@@ -4406,7 +4890,7 @@ var CREATE_BELIEF = {
       description: "Optional extra metadata merged into the node (e.g., { codeAnchors: ['path/to/file.ts'] } for coding intelligence)"
     }
   },
-  required: ["canonicalText", "baseRate"],
+  required: ["canonicalText"],
   response: {
     description: "The created canonical belief record",
     fields: {
@@ -4469,7 +4953,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. Triggers: evidence_added, evidence_removed, contradiction_detected, contradiction_resolved, agent_assessment, worktree_outcome, worktree_completed, fusion, discount, deduction, manual, decay.",
+  description: "Record a confidence change for a belief. Like `git commit` to the credence log \u2014 an atomic, append-only write. Each modulation is a new entry in the history, not an overwrite. Scoring happens via merge; this tool records the individual data points. Pass the full subjective-logic tuple (`belief`, `disbelief`, `uncertainty`, `baseRate`) directly. If a caller only has a scalar probability, use `@lucern/sdk` helpers `opinionFromBaseRate`, `opinionFromDogmatic`, or `opinionFromProjected` to name the intended interpretation before calling this tool. Every modulation must cite a truth-bearing artifact: triggeringEvidenceId, triggeringQuestionId, triggeringAnswerId, triggeringContradictionId, or triggeringWorktreeId. Triggers: evidence_added, evidence_removed, contradiction_detected, contradiction_resolved, agent_assessment, worktree_outcome, worktree_completed, fusion, discount, deduction.",
   parameters: {
     nodeId: { type: "string", description: "The belief to score" },
     belief: {
@@ -4488,9 +4972,9 @@ var MODULATE_CONFIDENCE = {
       type: "number",
       description: "Subjective-logic base rate `a` in [0, 1]. Required for tuple payloads."
     },
-    confidence: {
-      type: "number",
-      description: "Deprecated scalar confidence value in [0, 1]. Scalar-only payloads are rejected as AMBIGUOUS_SCALAR."
+    worktreeId: {
+      type: "string",
+      description: "Completed worktree that tested this belief when confidence policy requires merge-backed scoring."
     },
     trigger: {
       type: "string",
@@ -4505,17 +4989,43 @@ var MODULATE_CONFIDENCE = {
         "worktree_completed",
         "fusion",
         "discount",
-        "deduction",
-        "manual",
-        "decay"
+        "deduction"
       ]
     },
+    triggeringEvidenceId: {
+      type: "string",
+      description: "Evidence node that caused an evidence-triggered modulation"
+    },
+    triggeringQuestionId: {
+      type: "string",
+      description: "Answered question whose resolution supports this modulation"
+    },
+    triggeringAnswerId: {
+      type: "string",
+      description: "Answer node whose content supports this modulation"
+    },
+    triggeringContradictionId: {
+      type: "string",
+      description: "Contradiction record that caused a contradiction-triggered modulation"
+    },
+    triggeringWorktreeId: {
+      type: "string",
+      description: "Completed worktree whose outcome caused a worktree-triggered modulation"
+    },
     rationale: {
       type: "string",
       description: "Human-readable explanation of why confidence changed"
     }
   },
-  required: ["nodeId", "trigger", "rationale"],
+  required: [
+    "nodeId",
+    "belief",
+    "disbelief",
+    "uncertainty",
+    "baseRate",
+    "trigger",
+    "rationale"
+  ],
   response: {
     description: "Confidence modulation result",
     fields: {
@@ -4709,7 +5219,7 @@ var ADD_EVIDENCE = {
       description: "Optional extra metadata merged into the node (e.g., { codeAnchors: ['path/to/file.ts'], failedApproach: true } for coding intelligence)"
     }
   },
-  required: ["canonicalText", "targetNodeId"],
+  required: ["canonicalText", "targetNodeId", "reasoning"],
   response: {
     description: "The created evidence node and its edge",
     fields: {
@@ -4790,9 +5300,21 @@ var ADD_WORKTREE = {
       type: "string",
       description: "Optional domain pack whose shaping hooks should influence generated questions and tasks"
     },
-    executionOrder: {
+    campaign: {
+      type: "number",
+      description: "Top-level pipeline campaign number. Campaigns define the outer execution slice."
+    },
+    lane: {
+      type: "string",
+      description: "GitButler-aligned workstream lane name inside the campaign."
+    },
+    laneOrderInCampaign: {
+      type: "number",
+      description: "Ordering for this lane within its campaign."
+    },
+    orderInLane: {
       type: "number",
-      description: "Global execution order for this worktree"
+      description: "Position of this worktree inside its lane."
     },
     dependsOn: {
       type: "array",
@@ -5450,6 +5972,10 @@ var CREATE_EVIDENCE = {
       type: "object",
       description: "Optional metadata merged into the canonical evidence node"
     },
+    rationale: {
+      type: "string",
+      description: "Why this evidence should enter the reasoning graph"
+    },
     title: { type: "string", description: "Optional short title" },
     content: { type: "string", description: "Optional long-form content" },
     contentType: {
@@ -5458,7 +5984,7 @@ var CREATE_EVIDENCE = {
     },
     kind: { type: "string", description: "Optional evidence kind" }
   },
-  required: ["text"],
+  required: ["text", "rationale"],
   response: {
     description: "The created canonical evidence record",
     fields: {
@@ -5506,7 +6032,7 @@ var LIST_EVIDENCE = {
     limit: { type: "number", description: "Max results" },
     cursor: { type: "string", description: "Pagination cursor" }
   },
-  required: [],
+  required: ["topicId"],
   response: {
     description: "Canonical evidence page",
     fields: {
@@ -5691,6 +6217,7 @@ var ANSWER_QUESTION = {
   description: "Answer a question with optional evidence links. Like `git commit` on the question thread \u2014 records the answer and closes the loop with a canonical answered state.",
   parameters: {
     id: { type: "string", description: "Canonical question ID" },
+    topicId: { type: "string", description: "Topic scope for the answer" },
     text: { type: "string", description: "Answer text" },
     confidence: {
       type: "string",
@@ -5703,7 +6230,7 @@ var ANSWER_QUESTION = {
     },
     rationale: { type: "string", description: "Why this answer is credible" }
   },
-  required: ["id", "text"],
+  required: ["id", "topicId", "text"],
   response: {
     description: "Answer result",
     fields: {
@@ -5922,6 +6449,10 @@ var LIST_BELIEFS = {
     minConfidence: {
       type: "number",
       description: "Minimum confidence threshold"
+    },
+    limit: {
+      type: "number",
+      description: "Maximum results"
     }
   },
   required: ["topicId"],
@@ -5938,20 +6469,37 @@ var LIST_BELIEFS = {
 };
 var LIST_WORKTREES = {
   name: "list_worktrees",
-  description: "List all worktrees for a topic. Like `git worktree list` \u2014 shows active and completed investigation branches with their phase, status, and belief counts.",
+  description: "List all worktrees for a topic. Like `git worktree list` \u2014 shows active and completed investigation branches with lifecycle phase, pipeline campaign/lane, status, and belief counts.",
   parameters: {
     topicId: { type: "string", description: "Topic scope" },
     status: {
       type: "string",
       description: "Filter: active, merged, abandoned",
       enum: ["active", "merged", "abandoned"]
+    },
+    groupBy: {
+      type: "string",
+      description: "Optional grouping mode for the response.",
+      enum: ["campaign", "lane", "flat"]
+    },
+    lane: {
+      type: "string",
+      description: "Filter by GitButler-aligned lane name."
+    },
+    campaign: {
+      type: "number",
+      description: "Filter by top-level pipeline campaign number."
+    },
+    limit: {
+      type: "number",
+      description: "Maximum results to return."
     }
   },
   required: ["topicId"],
   response: {
-    description: "Worktrees with phase, status, belief count, and creation time",
+    description: "Worktrees with lifecycle phase, campaign, lane, status, belief count, and creation time",
     fields: {
-      worktrees: "array \u2014 { worktreeId, title, phase, status, beliefCount, createdAt }"
+      worktrees: "array \u2014 { worktreeId, title, phase, campaign, lane, laneOrderInCampaign, orderInLane, status, beliefCount, createdAt }"
     }
   },
   ownerModule: "workflow-engine",
@@ -5960,7 +6508,7 @@ var LIST_WORKTREES = {
 };
 var LIST_ALL_WORKTREES = {
   name: "list_all_worktrees",
-  description: "List ALL worktrees across ALL topics in one query. No topic scope required. Like `git worktree list --all` \u2014 returns the complete pipeline inventory with track, trackPosition, executionBand, dependencies, and status. Supports filtering by status, track, and executionBand. This is the PM's primary pipeline query \u2014 one call, full picture.",
+  description: "List ALL worktrees across ALL topics in one query. No topic scope required. Like `git worktree list --all` \u2014 returns the complete pipeline inventory with campaign, lane, lane order, dependencies, and status. Supports filtering by status, lane, and campaign. This is the PM's primary pipeline query \u2014 one call, full picture.",
   parameters: {
     status: {
       type: "string",
@@ -5978,13 +6526,18 @@ var LIST_ALL_WORKTREES = {
         "dismissed"
       ]
     },
-    track: {
+    lane: {
       type: "string",
-      description: "Filter by track name (e.g., 'ontology', 'tc-scope', 'control-plane', 'dev-portal', 'mcp-sdk-parity')"
+      description: "Filter by lane name (e.g., 'ontology', 'tc-scope', 'control-plane', 'dev-portal', 'mcp-sdk-parity')"
     },
-    executionBand: {
+    campaign: {
       type: "number",
-      description: "Filter by execution band number (e.g., 1, 2, 3). Returns only worktrees in that parallel execution group."
+      description: "Filter by campaign number (e.g., 1, 2, 3). Returns only worktrees in that campaign."
+    },
+    groupBy: {
+      type: "string",
+      description: "Optional grouping mode for the response.",
+      enum: ["campaign", "lane", "flat"]
     },
     limit: {
       type: "number",
@@ -5995,10 +6548,39 @@ var LIST_ALL_WORKTREES = {
   response: {
     description: "All worktrees across all topics with full pipeline metadata",
     fields: {
-      worktrees: "array \u2014 { worktreeId, title, topicId, topicName, phase, status, hypothesis, track, trackPosition, executionBand, executionOrder, dependsOn, blocks, gate, createdAt }",
+      worktrees: "array \u2014 { worktreeId, title, topicId, topicName, phase, status, hypothesis, campaign, lane, laneOrderInCampaign, orderInLane, dependsOn, blocks, gate, createdAt }",
       total: "number \u2014 total count after filtering",
-      tracks: "object \u2014 { trackName: count } summary of worktrees per track",
-      bands: "object \u2014 { bandNumber: count } summary of worktrees per execution band"
+      lanes: "object \u2014 { laneName: count } summary of worktrees per lane",
+      campaigns: "object \u2014 { campaignNumber: count } summary of worktrees per campaign"
+    }
+  },
+  ownerModule: "workflow-engine",
+  ontologyPrimitive: "worktree",
+  tier: "showcase"
+};
+var LIST_CAMPAIGNS = {
+  name: "list_campaigns",
+  description: "List compact pipeline campaigns with their nested lanes. Use this to see the top-level campaign > lane > worktree shape without pulling the full worktree inventory.",
+  parameters: {
+    topicId: {
+      type: "string",
+      description: "Optional topic scope."
+    },
+    status: {
+      type: "string",
+      description: "Optional worktree status filter before grouping campaigns and lanes."
+    },
+    limit: {
+      type: "number",
+      description: "Maximum worktrees to scan before grouping."
+    }
+  },
+  required: [],
+  response: {
+    description: "Pipeline campaigns with nested lane summaries.",
+    fields: {
+      campaigns: "array \u2014 { campaign, lanes: [{ lane, laneOrderInCampaign, worktreeCount, activeCount, readyCount, blockedCount, completedCount, nextWorktree }] }",
+      totalWorktrees: "number \u2014 total worktrees scanned after filtering"
     }
   },
   ownerModule: "workflow-engine",
@@ -6061,16 +6643,28 @@ var UPDATE_WORKTREE_TARGETS = {
 };
 var UPDATE_WORKTREE_METADATA = {
   name: "update_worktree_metadata",
-  description: "Update worktree sequencing metadata \u2014 execution order, dependencies, blocking relations, and gates. Like `git config` for a worktree \u2014 sets the scheduling and dependency metadata that determines when this worktree can activate relative to others. Use to backfill or correct sequencing data.",
+  description: "Update worktree sequencing metadata \u2014 campaign, lane, dependencies, blocking relations, and gates. Like `git config` for a worktree \u2014 sets the scheduling and dependency metadata that determines when this worktree can activate relative to others. Use to backfill or correct sequencing data.",
   parameters: {
     worktreeId: { type: "string", description: "The worktree to update" },
     hypothesis: {
       type: "string",
       description: "Testable claim this worktree investigates"
     },
-    executionOrder: {
+    campaign: {
+      type: "number",
+      description: "Top-level pipeline campaign number."
+    },
+    lane: {
+      type: "string",
+      description: "GitButler-aligned workstream lane name inside the campaign."
+    },
+    laneOrderInCampaign: {
+      type: "number",
+      description: "Ordering for this lane within the campaign."
+    },
+    orderInLane: {
       type: "number",
-      description: "Global execution order (1 = first, higher = later)"
+      description: "Position of this worktree inside its lane."
     },
     dependsOn: {
       type: "array",
@@ -6108,18 +6702,6 @@ var UPDATE_WORKTREE_METADATA = {
       type: "object",
       description: "Calibrated auto-fix policy controlling dry-run vs safe execution, per-run action caps, and permitted mutation tiers."
     },
-    track: {
-      type: "string",
-      description: "Parallel workstream name (e.g., 'ontology', 'tc-scope', 'control-plane', 'dev-portal', 'mcp-sdk-parity', 'execution-program'). Groups worktrees into named lanes for pipeline visualization and PM analysis."
-    },
-    trackPosition: {
-      type: "number",
-      description: "Position within the track (1-indexed). E.g., TC-A=1, TC-B=2, TC-C=3 within the 'tc-scope' track."
-    },
-    executionBand: {
-      type: "number",
-      description: "Parallel execution band number. All worktrees in the same band can run simultaneously. Band 2 = OE-B + TC-A, Band 3 = TC-B + 11D-R + S2-13A, etc."
-    },
     status: {
       type: "string",
       description: "Override the worktree status. Use for lifecycle transitions like marking a worktree superseded, long-term, or as a raw idea.",
@@ -6489,6 +7071,10 @@ var LIST_TASKS = {
       type: "string",
       description: "Filter to tasks linked to this worktree"
     },
+    worktreeId: {
+      type: "string",
+      description: "Alias for linkedWorktreeId"
+    },
     status: {
       type: "string",
       description: "Filter by status: todo, in_progress, blocked, done",
@@ -6576,7 +7162,7 @@ var GET_TOPIC = {
       description: "Legacy alias for topicId"
     }
   },
-  required: [],
+  required: ["topicId"],
   response: {
     description: "Single topic record",
     fields: {
@@ -6931,7 +7517,7 @@ var GET_ONTOLOGY = {
       description: "Tenant scope for key lookup. Omit for platform-level."
     }
   },
-  required: [],
+  required: ["id"],
   response: {
     description: "Ontology definition with latest published version",
     fields: {
@@ -6998,7 +7584,7 @@ var MATCH_ENTITY_TYPE = {
       description: "Optional maximum number of ranked matches to return"
     }
   },
-  required: ["text"],
+  required: ["text", "ontologyId"],
   response: {
     description: "Ranked ontology entity type matches",
     fields: {
@@ -7252,7 +7838,7 @@ var RECORD_SCOPE_LEARNING = {
 };
 var PIPELINE_SNAPSHOT = {
   name: "pipeline_snapshot",
-  description: "Summarize a topic's worktree pipeline in band-and-lane form. Like `git status --short` for Lucern execution \u2014 returns the hinge worktree, next planned wave, blockers, critical path, superseded work, and graph hygiene debt.",
+  description: "Summarize a topic's worktree pipeline in campaign-and-lane form. Like `git status --short` for Lucern execution \u2014 returns the hinge worktree, next planned wave, blockers, critical path, superseded work, and graph hygiene debt.",
   parameters: {
     topicId: { type: "string", description: "Topic scope ID" }
   },
@@ -7262,14 +7848,14 @@ var PIPELINE_SNAPSHOT = {
     fields: {
       topicId: "string",
       topicName: "string",
-      currentBand: "number | null",
-      nextBand: "number | null",
+      currentCampaign: "number | null",
+      nextCampaign: "number | null",
       activeWorktrees: "array \u2014 current hinge worktree(s)",
-      nextWave: "array \u2014 worktrees in the next planned band",
+      nextWave: "array \u2014 worktrees in the next planned campaign",
       readyNow: "array \u2014 planning worktrees with dependencies completed",
       blockedBy: "array \u2014 grouped blockers",
       criticalPath: "array \u2014 ordered incomplete worktree chain",
-      bands: "array \u2014 incomplete worktrees grouped by executionBand",
+      campaigns: "array \u2014 incomplete worktrees grouped by campaign",
       superseded: "array \u2014 worktrees marked superseded or not for activation",
       graphHygiene: "object \u2014 untargeted and taskless worktree debt",
       riskQuestions: "array \u2014 critical/high open questions",
@@ -7858,6 +8444,7 @@ var MCP_TOOL_CONTRACTS = {
   list_beliefs: LIST_BELIEFS,
   list_worktrees: LIST_WORKTREES,
   list_all_worktrees: LIST_ALL_WORKTREES,
+  list_campaigns: LIST_CAMPAIGNS,
   activate_worktree: ACTIVATE_WORKTREE,
   update_worktree_targets: UPDATE_WORKTREE_TARGETS,
   update_worktree_metadata: UPDATE_WORKTREE_METADATA,
@@ -8040,6 +8627,7 @@ var MCP_WORKFLOW_PLATFORM_OPERATION_NAMES = [
   "activate_worktree",
   "list_worktrees",
   "list_all_worktrees",
+  "list_campaigns",
   "update_worktree_targets",
   "update_worktree_metadata",
   "create_task",
@@ -8247,6 +8835,7 @@ var LUCERN_OPERATION_MANIFEST = {
 
 // ../contracts/src/function-registry/helpers.ts
 var jsonObjectSchema = z.record(z.unknown());
+var sdkSessionIdSchema = z.string().optional();
 function mcpContractShape(contract) {
   const required = new Set(contract.required);
   return Object.fromEntries(
@@ -8281,10 +8870,40 @@ function argsSchemaFromMcpContract(contract) {
   return z.object(mcpContractShape(contract));
 }
 function inputSchemaFromMcpContract(contract) {
-  return argsSchemaFromMcpContract(contract).passthrough();
+  return withInternalSurfaceFields(argsSchemaFromMcpContract(contract));
+}
+function withInternalSurfaceFields(schema) {
+  return schema.extend({ __sdkSessionId: sdkSessionIdSchema }).strict();
+}
+function normalizeInputSchema(schema) {
+  if (schema instanceof z.ZodObject) {
+    return withInternalSurfaceFields(schema);
+  }
+  return schema;
+}
+function unwrapObjectSchema(schema) {
+  let current = schema;
+  while (true) {
+    switch (current._def.typeName) {
+      case z.ZodFirstPartyTypeKind.ZodEffects:
+        current = current._def.schema;
+        continue;
+      case z.ZodFirstPartyTypeKind.ZodBranded:
+        current = current._def.type;
+        continue;
+      default:
+        return current instanceof z.ZodObject ? current : void 0;
+    }
+  }
 }
 function getObjectShape(schema) {
-  const shape = typeof schema._def.shape === "function" ? schema._def.shape() : schema._def.shape;
+  const objectSchema = unwrapObjectSchema(schema);
+  if (!objectSchema) {
+    throw new Error(
+      `Expected a Zod object schema, received ${schema._def.typeName}.`
+    );
+  }
+  const shape = typeof objectSchema._def.shape === "function" ? objectSchema._def.shape() : objectSchema._def.shape;
   return shape;
 }
 function unwrapMcpParameterSchema(schema) {
@@ -8305,6 +8924,9 @@ function unwrapMcpParameterSchema(schema) {
       case z.ZodFirstPartyTypeKind.ZodBranded:
         current = current._def.type;
         continue;
+      case z.ZodFirstPartyTypeKind.ZodEffects:
+        current = current._def.schema;
+        continue;
       default:
         return { schema: current, required, description: description ?? current.description };
     }
@@ -8324,6 +8946,7 @@ function mcpParameterFromZod(fieldName, schema, contractName) {
       return { parameter: { type: "array", description }, required };
     case z.ZodFirstPartyTypeKind.ZodObject:
     case z.ZodFirstPartyTypeKind.ZodRecord:
+    case z.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       return { parameter: { type: "object", description }, required };
     case z.ZodFirstPartyTypeKind.ZodEnum:
       return {
@@ -8385,6 +9008,14 @@ function withCreatedBy(input, context) {
     createdBy: typeof input.createdBy === "string" ? input.createdBy : authUserId(context)
   };
 }
+function compactRecord4(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => value !== void 0)
+  );
+}
+function recordValue2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
 function surfaceMcpContract(name) {
   const contract = MCP_TOOL_CONTRACTS[name];
   if (!contract) {
@@ -8429,7 +9060,9 @@ function surfaceContract(args) {
   const canonicalArgs = args.args ?? argsSchemaFromMcpContract(baseMcp);
   const mcp = args.args ? mcpContractFromArgsSchema(baseMcp, canonicalArgs, args.name) : baseMcp;
   const canonicalReturns = args.returns ?? jsonObjectSchema;
-  const input = args.input ?? inputSchemaFromMcpContract(mcp);
+  const input = normalizeInputSchema(
+    args.input ?? inputSchemaFromMcpContract(mcp)
+  );
   const output = args.output ?? canonicalReturns;
   return defineFunctionContract({
     name: args.name,
@@ -8491,20 +9124,26 @@ function assertSurfaceCoverage(contracts) {
 
 // ../contracts/src/function-registry/context.ts
 var observationInput = (input, context) => withUserId(
-  {
-    ...input,
+  compactRecord4({
+    projectId: input.projectId,
+    topicId: input.topicId,
     text: input.text ?? input.summary,
     title: input.title ?? input.summary,
     content: input.content ?? input.summary,
+    contentType: input.contentType,
     kind: input.kind ?? input.observationType ?? "observation",
-    sourceType: input.sourceType ?? input.source ?? "agent",
-    metadata: {
-      ...input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata) ? input.metadata : {},
+    tags: input.tags,
+    sourceType: input.sourceType,
+    externalSourceType: input.externalSourceType,
+    sourceUrl: input.sourceUrl,
+    metadata: compactRecord4({
+      ...recordValue2(input.metadata),
       observationType: input.observationType,
       source: input.source
-    },
+    }),
+    rationale: input.rationale ?? input.reasoning ?? input.summary ?? input.text ?? "Recorded observation",
     trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
-  },
+  }),
   context
 );
 var contextContracts = [
@@ -8556,7 +9195,13 @@ var contextContracts = [
     convex: {
       module: "evidence",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        topicId: input.topicId,
+        limit: input.limit,
+        status: input.status,
+        userId: input.userId
+      })
     }
   })
 ];
@@ -8622,42 +9267,62 @@ var identityContracts = [
 ];
 
 // ../contracts/src/function-registry/beliefs.ts
-var withBeliefId = (input) => ({
-  ...input,
+var beliefLookupInput = (input) => compactRecord4({
   nodeId: input.nodeId ?? input.id ?? input.beliefId,
-  beliefId: input.beliefId ?? input.id ?? input.nodeId
+  beliefId: input.beliefId
 });
-var createBeliefInput = (input, context) => withUserId(
-  {
-    ...input,
-    formulation: input.formulation ?? input.canonicalText,
-    baseRate: input.baseRate ?? 0.5,
-    trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
-  },
-  context
-);
+var beliefNodeInput = (input) => compactRecord4({
+  nodeId: input.nodeId ?? input.id ?? input.beliefId
+});
+var beliefTopicInput = (input) => {
+  const parsed = listBeliefsProjection.inputSchema.safeParse(input);
+  if (!parsed.success) {
+    throw new Error(
+      `list_beliefs projection input rejected: ${parsed.error.message}`
+    );
+  }
+  return compactRecord4(listBeliefsProjection.project(parsed.data));
+};
+var createBeliefInput = (input, context) => {
+  return withUserId(
+    compactRecord4({
+      projectId: input.projectId,
+      topicId: input.topicId,
+      formulation: input.formulation ?? input.canonicalText,
+      beliefType: input.beliefType,
+      rationale: input.rationale,
+      pillar: input.pillar,
+      worktreeId: input.worktreeId,
+      sourceBeliefIds: input.sourceBeliefIds,
+      sourceType: input.sourceType,
+      reversibility: input.reversibility,
+      predictionMeta: input.predictionMeta,
+      baseRate: input.baseRate ?? 0.5,
+      metadata: input.metadata,
+      trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
+    }),
+    context
+  );
+};
 var forkBeliefInput = (input, context) => withUserId(
-  {
-    ...input,
+  compactRecord4({
     parentNodeId: input.parentNodeId ?? input.nodeId ?? input.id,
+    newFormulation: input.newFormulation,
+    forkReason: input.forkReason,
+    rationale: input.rationale,
     trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
-  },
+  }),
   context
 );
 var confidenceInput = (input, context) => {
-  const confidence = typeof input.confidence === "number" ? input.confidence : void 0;
-  const belief = typeof input.belief === "number" ? input.belief : confidence ?? 0.5;
-  const disbelief = typeof input.disbelief === "number" ? input.disbelief : 0;
-  const uncertainty = typeof input.uncertainty === "number" ? input.uncertainty : Math.max(0, 1 - belief - disbelief);
+  const parsed = modulateConfidenceProjection.inputSchema.safeParse(input);
+  if (!parsed.success) {
+    throw new Error(
+      `modulate_confidence projection input rejected: ${parsed.error.message}`
+    );
+  }
   return withUserId(
-    {
-      ...input,
-      belief,
-      disbelief,
-      uncertainty,
-      baseRate: input.baseRate ?? 0.5,
-      trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
-    },
+    compactRecord4(modulateConfidenceProjection.project(parsed.data)),
     context
   );
 };
@@ -8692,7 +9357,7 @@ var beliefsContracts = [
       module: "beliefs",
       functionName: "getById",
       kind: "query",
-      inputProjection: withBeliefId
+      inputProjection: beliefLookupInput
     }
   }),
   surfaceContract({
@@ -8708,8 +9373,10 @@ var beliefsContracts = [
     convex: {
       module: "beliefs",
       functionName: "getByTopic",
-      kind: "query"
-    }
+      kind: "query",
+      inputProjection: beliefTopicInput
+    },
+    args: listBeliefsInputSchema
   }),
   surfaceContract({
     name: "refine_belief",
@@ -8727,7 +9394,7 @@ var beliefsContracts = [
       kind: "mutation",
       inputProjection: (input, context) => withUserId(
         {
-          ...withBeliefId(input),
+          ...beliefLookupInput(input),
           trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
         },
         context
@@ -8748,7 +9415,8 @@ var beliefsContracts = [
       functionName: "modulateConfidence",
       kind: "mutation",
       inputProjection: confidenceInput
-    }
+    },
+    args: modulateConfidenceInputSchema
   }),
   surfaceContract({
     name: "fork_belief",
@@ -8781,10 +9449,10 @@ var beliefsContracts = [
       functionName: "archive",
       kind: "mutation",
       inputProjection: (input, context) => withUserId(
-        {
-          ...withBeliefId(input),
+        compactRecord4({
+          ...beliefNodeInput(input),
           reason: input.reason ?? input.rationale
-        },
+        }),
         context
       )
     }
@@ -8802,10 +9470,12 @@ var beliefsContracts = [
       module: "nodes",
       functionName: "search",
       kind: "query",
-      inputProjection: (input) => ({
-        ...input,
+      inputProjection: (input) => compactRecord4({
         searchQuery: input.searchQuery ?? input.query,
-        nodeType: "belief"
+        projectId: input.projectId,
+        topicId: input.topicId,
+        nodeType: "belief",
+        limit: input.limit
       })
     }
   }),
@@ -8822,7 +9492,7 @@ var beliefsContracts = [
       module: "beliefs",
       functionName: "getConfidenceHistory",
       kind: "query",
-      inputProjection: withBeliefId
+      inputProjection: beliefNodeInput
     }
   }),
   surfaceContract({
@@ -8839,25 +9509,69 @@ var beliefsContracts = [
       module: "beliefs",
       functionName: "getConfidenceHistory",
       kind: "query",
-      inputProjection: withBeliefId
+      inputProjection: beliefNodeInput
     }
   })
 ];
 
 // ../contracts/src/function-registry/evidence.ts
-var evidenceIdInput = (input) => ({
-  ...input,
-  evidenceId: input.evidenceId ?? input.id ?? input.nodeId,
+var evidenceIdInput = (input) => compactRecord4({
+  evidenceId: input.evidenceId,
+  insightId: input.insightId,
   nodeId: input.nodeId ?? input.id ?? input.evidenceId
 });
-var createEvidenceInput = (input, context) => withUserId(
-  {
-    ...input,
-    title: input.title ?? input.text,
-    content: input.content ?? input.text,
-    sourceType: input.sourceType ?? input.source ?? "agent",
+var evidenceTopicInput = (input) => compactRecord4({
+  topicId: input.topicId,
+  status: input.status,
+  userId: input.userId,
+  limit: input.limit
+});
+var createEvidenceInput = (input, context) => {
+  const parsed = createEvidenceProjection.inputSchema.safeParse(input);
+  if (!parsed.success) {
+    throw new Error(
+      `create_evidence projection input rejected: ${parsed.error.message}`
+    );
+  }
+  return withUserId(
+    compactRecord4(createEvidenceProjection.project(parsed.data)),
+    context
+  );
+};
+var linkEvidenceToBeliefEdgeInput = (input, context) => withCreatedBy(
+  compactRecord4({
+    fromNodeId: input.insightId ?? input.evidenceNodeId ?? input.evidenceId,
+    toNodeId: input.beliefNodeId ?? input.beliefId ?? input.targetId,
+    edgeType: "evidence_supports_belief",
+    globalId: input.globalId ?? `edge:${String(
+      input.insightId ?? input.evidenceNodeId ?? input.evidenceId
+    )}:${String(
+      input.beliefNodeId ?? input.beliefId ?? input.targetId
+    )}:evidence_supports_belief`,
+    weight: typeof input.weight === "number" ? input.weight : input.type === "contradicting" ? -1 : 1,
+    context: input.rationale ?? input.context,
+    skipLayerValidation: true,
+    topicId: input.topicId,
     trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
-  },
+  }),
+  context
+);
+var linkEvidenceToQuestionEdgeInput = (input, context) => withCreatedBy(
+  compactRecord4({
+    fromNodeId: input.insightId ?? input.evidenceNodeId ?? input.evidenceId,
+    toNodeId: input.questionId ?? input.questionNodeId ?? input.targetId,
+    edgeType: "evidence_supports_question",
+    globalId: input.globalId ?? `edge:${String(
+      input.insightId ?? input.evidenceNodeId ?? input.evidenceId
+    )}:${String(
+      input.questionId ?? input.questionNodeId ?? input.targetId
+    )}:evidence_supports_question`,
+    weight: input.impactScore ?? input.weight,
+    context: input.rationale ?? input.context,
+    skipLayerValidation: true,
+    topicId: input.topicId,
+    trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
+  }),
   context
 );
 var evidenceContracts = [
@@ -8901,8 +9615,9 @@ var evidenceContracts = [
             linkedBeliefNodeId: input.linkedBeliefNodeId ?? input.targetNodeId ?? input.targetId,
             evidenceRelation: weight < 0 ? "contradicts" : "supports",
             confidence: Math.min(1, Math.max(0, Math.abs(weight))),
+            rationale: input.reasoning,
             metadata: {
-              ...input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata) ? input.metadata : {},
+              ...recordValue2(input.metadata),
               reasoning: input.reasoning,
               sourceUrl: input.sourceUrl
             }
@@ -8942,7 +9657,8 @@ var evidenceContracts = [
     convex: {
       module: "evidence",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: evidenceTopicInput
     }
   }),
   surfaceContract({
@@ -8958,10 +9674,12 @@ var evidenceContracts = [
       module: "nodes",
       functionName: "search",
       kind: "query",
-      inputProjection: (input) => ({
-        ...input,
+      inputProjection: (input) => compactRecord4({
         searchQuery: input.searchQuery ?? input.q ?? input.query,
-        nodeType: "evidence"
+        projectId: input.projectId,
+        topicId: input.topicId,
+        nodeType: "evidence",
+        limit: input.limit
       })
     }
   }),
@@ -8975,17 +9693,10 @@ var evidenceContracts = [
     sdkMethod: "linkEvidenceToBelief",
     summary: "Link evidence to a belief.",
     convex: {
-      module: "beliefs",
-      functionName: "linkEvidence",
+      module: "edges",
+      functionName: "create",
       kind: "mutation",
-      inputProjection: (input, context) => withUserId(
-        {
-          ...input,
-          beliefNodeId: input.beliefNodeId ?? input.beliefId ?? input.targetId,
-          evidenceNodeId: input.evidenceNodeId ?? input.evidenceId
-        },
-        context
-      )
+      inputProjection: linkEvidenceToBeliefEdgeInput
     }
   }),
   surfaceContract({
@@ -8998,18 +9709,10 @@ var evidenceContracts = [
     sdkMethod: "linkEvidenceToQuestion",
     summary: "Link evidence to a question.",
     convex: {
-      module: "questionLinks",
+      module: "edges",
       functionName: "create",
       kind: "mutation",
-      inputProjection: (input, context) => withCreatedBy(
-        {
-          ...input,
-          questionId: input.questionId,
-          insightId: input.insightId ?? input.evidenceId,
-          helpsAnswer: input.helpsAnswer ?? true
-        },
-        context
-      )
+      inputProjection: linkEvidenceToQuestionEdgeInput
     }
   }),
   surfaceContract({
@@ -9022,35 +9725,46 @@ var evidenceContracts = [
     sdkMethod: "linkEvidence",
     summary: "Link evidence to a target node.",
     convex: {
-      module: "beliefs",
-      functionName: "linkEvidence",
+      module: "edges",
+      functionName: "create",
       kind: "mutation",
-      inputProjection: (input, context) => withUserId(
-        {
-          ...input,
-          beliefNodeId: input.beliefNodeId ?? input.targetId,
-          evidenceNodeId: input.evidenceNodeId ?? input.evidenceId
-        },
-        context
-      )
+      inputProjection: linkEvidenceToBeliefEdgeInput
     }
   })
 ];
 
 // ../contracts/src/function-registry/questions.ts
-var questionIdInput = (input) => ({
-  ...input,
-  questionId: input.questionId ?? input.id ?? input.nodeId,
-  nodeId: input.nodeId ?? input.id ?? input.questionId
+var questionNodeInput = (input) => compactRecord4({
+  nodeId: input.nodeId ?? input.id ?? input.questionId,
+  questionId: input.questionId
 });
-var createQuestionInput = (input, context) => withUserId(
-  {
-    ...input,
-    text: input.text ?? input.question,
-    trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
-  },
-  context
-);
+var questionTopicInput = (input) => compactRecord4({
+  topicId: input.topicId,
+  status: input.status,
+  userId: input.userId,
+  limit: input.limit
+});
+var createQuestionInput = (input, context) => {
+  const priority = input.priority === "urgent" ? "high" : input.priority;
+  return withUserId(
+    compactRecord4({
+      topicId: input.topicId,
+      question: input.question ?? input.text,
+      category: input.category,
+      priority,
+      source: input.source,
+      linkedBeliefNodeId: input.linkedBeliefNodeId ?? input.linkedBeliefId,
+      testType: input.testType,
+      importance: input.importance,
+      epistemicUnlock: input.epistemicUnlock,
+      sourceQuestionIds: input.sourceQuestionIds,
+      linkedWorktreeId: input.linkedWorktreeId,
+      questionType: input.questionType,
+      questionPriority: input.questionPriority
+    }),
+    context
+  );
+};
 var questionsContracts = [
   surfaceContract({
     name: "create_question",
@@ -9082,7 +9796,7 @@ var questionsContracts = [
       module: "questions",
       functionName: "getById",
       kind: "query",
-      inputProjection: questionIdInput
+      inputProjection: questionNodeInput
     }
   }),
   surfaceContract({
@@ -9098,7 +9812,8 @@ var questionsContracts = [
     convex: {
       module: "questions",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: questionTopicInput
     }
   }),
   surfaceContract({
@@ -9115,7 +9830,12 @@ var questionsContracts = [
       module: "questions",
       functionName: "updateQuestion",
       kind: "mutation",
-      inputProjection: (input, context) => withUserId({ ...questionIdInput(input), text: input.text }, context)
+      inputProjection: (input) => compactRecord4({
+        questionId: input.questionId ?? input.id ?? input.nodeId,
+        question: input.question ?? input.text,
+        category: input.category,
+        priority: input.priority
+      })
     }
   }),
   surfaceContract({
@@ -9132,7 +9852,16 @@ var questionsContracts = [
       module: "questions",
       functionName: "updateStatus",
       kind: "mutation",
-      inputProjection: (input, context) => withUserId(questionIdInput(input), context)
+      inputProjection: (input, context) => withUserId(
+        compactRecord4({
+          questionId: input.questionId ?? input.id,
+          nodeId: input.nodeId,
+          status: input.status,
+          answer: input.answer,
+          answerStatus: input.answerStatus
+        }),
+        context
+      )
     }
   }),
   surfaceContract({
@@ -9149,7 +9878,12 @@ var questionsContracts = [
       module: "questions",
       functionName: "deleteQuestion",
       kind: "mutation",
-      inputProjection: questionIdInput
+      inputProjection: (input, context) => withUserId(
+        compactRecord4({
+          questionId: input.questionId ?? input.id ?? input.nodeId
+        }),
+        context
+      )
     }
   }),
   surfaceContract({
@@ -9166,10 +9900,16 @@ var questionsContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: (input, context) => withUserId(
-        {
-          ...input,
-          questionNodeId: input.questionNodeId ?? input.questionId
-        },
+        compactRecord4({
+          topicId: input.topicId,
+          questionNodeId: input.questionNodeId ?? input.questionId,
+          answerText: input.answerText,
+          confidence: input.confidence,
+          evidenceNodeIds: input.evidenceNodeIds,
+          answerSource: input.answerSource,
+          worktreeId: input.worktreeId,
+          sprintId: input.sprintId
+        }),
         context
       )
     }
@@ -9189,13 +9929,16 @@ var questionsContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: (input, context) => withUserId(
-        {
-          ...input,
+        compactRecord4({
+          topicId: input.topicId,
           questionNodeId: input.questionNodeId ?? input.questionId ?? input.id,
           answerText: input.answerText ?? input.text,
           evidenceNodeIds: input.evidenceNodeIds ?? input.evidenceIds,
-          answerSource: input.answerSource ?? "human"
-        },
+          answerSource: input.answerSource ?? "human",
+          confidence: input.confidence,
+          worktreeId: input.worktreeId,
+          sprintId: input.sprintId
+        }),
         context
       )
     }
@@ -9228,7 +9971,8 @@ var questionsContracts = [
     convex: {
       module: "questions",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: questionTopicInput
     }
   }),
   surfaceContract({
@@ -9243,7 +9987,11 @@ var questionsContracts = [
     convex: {
       module: "questions",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        ...questionTopicInput(input),
+        status: input.includeAnswered === true ? void 0 : "open"
+      })
     }
   }),
   surfaceContract({
@@ -9258,16 +10006,28 @@ var questionsContracts = [
     convex: {
       module: "questions",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: questionTopicInput
     }
   })
 ];
 
 // ../contracts/src/function-registry/topics.ts
-var topicIdInput = (input) => ({
-  ...input,
+var topicIdInput = (input) => compactRecord4({
   id: input.id ?? input.topicId
 });
+var updateTopicInput = (input) => compactRecord4({
+  id: input.id ?? input.topicId,
+  name: input.name,
+  description: input.description,
+  type: input.type,
+  status: input.status,
+  visibility: input.visibility,
+  ontologyId: input.ontologyId,
+  clearOntologyId: input.clearOntologyId,
+  graphScopeProjectId: input.graphScopeProjectId,
+  metadata: input.metadata
+});
 var topicsContracts = [
   surfaceContract({
     name: "create_topic",
@@ -9332,7 +10092,7 @@ var topicsContracts = [
       module: "topics",
       functionName: "update",
       kind: "mutation",
-      inputProjection: topicIdInput
+      inputProjection: updateTopicInput
     }
   }),
   surfaceContract({
@@ -9354,6 +10114,27 @@ var topicsContracts = [
 ];
 
 // ../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 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",
@@ -9367,7 +10148,8 @@ var lensesContracts = [
     convex: {
       module: "lenses",
       functionName: "create",
-      kind: "mutation"
+      kind: "mutation",
+      inputProjection: createLensInput
     }
   }),
   surfaceContract({
@@ -9383,7 +10165,8 @@ var lensesContracts = [
     convex: {
       module: "lenses",
       functionName: "list",
-      kind: "query"
+      kind: "query",
+      inputProjection: lensListInput
     }
   }),
   surfaceContract({
@@ -9398,7 +10181,13 @@ var lensesContracts = [
     convex: {
       module: "lenses",
       functionName: "applyToTopic",
-      kind: "mutation"
+      kind: "mutation",
+      inputProjection: (input, context) => compactRecord4({
+        lensId: input.lensId,
+        topicId: input.topicId,
+        metadata: input.metadata,
+        appliedBy: authUserId(context)
+      })
     }
   }),
   surfaceContract({
@@ -9414,12 +10203,28 @@ var lensesContracts = [
     convex: {
       module: "lenses",
       functionName: "removeFromTopic",
-      kind: "mutation"
+      kind: "mutation",
+      inputProjection: (input, context) => compactRecord4({
+        lensId: input.lensId,
+        topicId: input.topicId,
+        removedBy: authUserId(context)
+      })
     }
   })
 ];
 
 // ../contracts/src/function-registry/ontologies.ts
+var ontologyIdInput = (input) => compactRecord4({
+  id: input.id ?? input.ontologyId
+});
+var ontologyVersionIdInput = (input) => compactRecord4({
+  id: input.id ?? input.versionId,
+  ontologyId: input.ontologyId,
+  actorId: input.actorId
+});
+var effectiveOntologyInput = (input) => compactRecord4({
+  ontologyId: input.ontologyId ?? input.id
+});
 var ontologiesContracts = [
   surfaceContract({
     name: "create_ontology",
@@ -9450,10 +10255,7 @@ var ontologiesContracts = [
       module: "ontologies",
       functionName: "getOntologyDefinition",
       kind: "query",
-      inputProjection: (input) => ({
-        ...input,
-        id: input.id ?? input.ontologyId
-      })
+      inputProjection: ontologyIdInput
     }
   }),
   surfaceContract({
@@ -9486,9 +10288,13 @@ var ontologiesContracts = [
       module: "ontologies",
       functionName: "updateOntologyDefinition",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...input,
-        id: input.id ?? input.ontologyId
+      inputProjection: (input) => compactRecord4({
+        id: input.id ?? input.ontologyId,
+        name: input.name,
+        description: input.description,
+        parentOntologyId: input.parentOntologyId,
+        status: input.status,
+        actorId: input.actorId
       })
     }
   }),
@@ -9506,10 +10312,7 @@ var ontologiesContracts = [
       module: "ontologies",
       functionName: "archiveOntologyDefinition",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...input,
-        id: input.id ?? input.ontologyId
-      })
+      inputProjection: ontologyIdInput
     }
   }),
   surfaceContract({
@@ -9540,8 +10343,7 @@ var ontologiesContracts = [
       module: "topics",
       functionName: "update",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...input,
+      inputProjection: (input) => compactRecord4({
         id: input.topicId ?? input.id,
         ontologyId: input.ontologyId ?? input.id
       })
@@ -9559,7 +10361,8 @@ var ontologiesContracts = [
     convex: {
       module: "ontologies",
       functionName: "resolveEffectiveOntology",
-      kind: "query"
+      kind: "query",
+      inputProjection: effectiveOntologyInput
     }
   }),
   surfaceContract({
@@ -9575,10 +10378,7 @@ var ontologiesContracts = [
       module: "ontologies",
       functionName: "publishOntologyVersion",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...input,
-        id: input.id ?? input.versionId
-      })
+      inputProjection: ontologyVersionIdInput
     }
   }),
   surfaceContract({
@@ -9594,10 +10394,7 @@ var ontologiesContracts = [
       module: "ontologies",
       functionName: "deprecateOntologyVersion",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...input,
-        id: input.id ?? input.versionId
-      })
+      inputProjection: ontologyVersionIdInput
     }
   }),
   surfaceContract({
@@ -9612,16 +10409,51 @@ var ontologiesContracts = [
     convex: {
       module: "ontologies",
       functionName: "resolveEffectiveOntology",
-      kind: "query"
+      kind: "query",
+      inputProjection: effectiveOntologyInput
     }
   })
 ];
 
 // ../contracts/src/function-registry/worktrees.ts
-var worktreeInput = (input) => ({
-  ...input,
+var worktreeIdInput = (input) => compactRecord4({
   worktreeId: input.worktreeId ?? input.id
 });
+var activateWorktreeInput = (input, context) => withUserId(worktreeIdInput(input), context);
+var worktreeTargetsInput = (input) => compactRecord4({
+  worktreeId: input.worktreeId ?? input.id,
+  addBeliefIds: input.addBeliefIds,
+  removeBeliefIds: input.removeBeliefIds,
+  addQuestionIds: input.addQuestionIds,
+  removeQuestionIds: input.removeQuestionIds
+});
+var worktreeMetadataInput = (input) => compactRecord4({
+  worktreeId: input.worktreeId ?? input.id,
+  topicId: input.topicId,
+  additionalTopicIds: input.additionalTopicIds,
+  status: input.status,
+  campaign: input.campaign,
+  lane: input.lane,
+  laneOrderInCampaign: input.laneOrderInCampaign,
+  orderInLane: input.orderInLane,
+  gate: input.gate,
+  hypothesis: input.hypothesis,
+  objective: input.objective,
+  rationale: input.rationale,
+  proofArtifacts: input.proofArtifacts,
+  staffingHint: input.staffingHint,
+  blocks: input.blocks,
+  dependsOn: input.dependsOn,
+  lensId: input.lensId,
+  autoFixPolicy: input.autoFixPolicy,
+  lastReconciledAt: input.lastReconciledAt
+});
+var listAllWorktreesInput = (input) => compactRecord4({
+  status: input.status,
+  lane: input.lane,
+  campaign: input.campaign,
+  limit: input.limit
+});
 var worktreesContracts = [
   surfaceContract({
     name: "add_worktree",
@@ -9637,11 +10469,43 @@ var worktreesContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: (input, context) => withCreatedBy(
-        {
-          ...input,
+        compactRecord4({
           name: input.name ?? input.title,
-          targetBeliefIds: input.targetBeliefIds ?? input.beliefIds
-        },
+          topicId: input.topicId,
+          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,
+          confidenceImpact: input.confidenceImpact,
+          autoShape: input.autoShape,
+          autoFixPolicy: input.autoFixPolicy,
+          beliefFocus: input.beliefFocus,
+          targetQuestionIds: input.targetQuestionIds,
+          targetBeliefIds: input.targetBeliefIds ?? input.beliefIds,
+          keyQuestions: input.keyQuestions,
+          proofArtifacts: input.proofArtifacts,
+          decisionGate: input.decisionGate ?? (input.goCriteria || input.noGoSignals ? compactRecord4({
+            goCriteria: input.goCriteria,
+            noGoSignals: input.noGoSignals
+          }) : void 0),
+          evidenceSignals: input.evidenceSignals,
+          dependsOn: input.dependsOn,
+          blocks: input.blocks,
+          campaign: input.campaign,
+          lane: input.lane,
+          laneOrderInCampaign: input.laneOrderInCampaign,
+          orderInLane: input.orderInLane,
+          staffingHint: input.staffingHint,
+          domainPackId: input.domainPackId,
+          lensId: input.lensId,
+          linkedQuestionId: input.linkedQuestionId,
+          lastReconciledAt: input.lastReconciledAt
+        }),
         context
       )
     }
@@ -9659,7 +10523,7 @@ var worktreesContracts = [
       module: "worktrees",
       functionName: "activate",
       kind: "mutation",
-      inputProjection: worktreeInput
+      inputProjection: activateWorktreeInput
     }
   }),
   surfaceContract({
@@ -9675,7 +10539,36 @@ var worktreesContracts = [
     convex: {
       module: "worktrees",
       functionName: "list",
-      kind: "query"
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        topicId: input.topicId,
+        status: input.status,
+        groupBy: input.groupBy,
+        lane: input.lane,
+        campaign: input.campaign,
+        limit: input.limit
+      })
+    }
+  }),
+  surfaceContract({
+    name: "list_campaigns",
+    kind: "query",
+    domain: "worktrees",
+    surfaceClass: "platform_public",
+    method: "GET",
+    path: "/worktrees/campaigns",
+    sdkNamespace: "worktrees",
+    sdkMethod: "listCampaigns",
+    summary: "List compact pipeline campaigns with nested lanes.",
+    convex: {
+      module: "worktrees",
+      functionName: "listCampaigns",
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        topicId: input.topicId,
+        status: input.status,
+        limit: input.limit
+      })
     }
   }),
   surfaceContract({
@@ -9691,7 +10584,8 @@ var worktreesContracts = [
     convex: {
       module: "worktrees",
       functionName: "listAll",
-      kind: "query"
+      kind: "query",
+      inputProjection: listAllWorktreesInput
     }
   }),
   surfaceContract({
@@ -9708,7 +10602,7 @@ var worktreesContracts = [
       module: "worktrees",
       functionName: "updateTargets",
       kind: "mutation",
-      inputProjection: worktreeInput
+      inputProjection: worktreeTargetsInput
     }
   }),
   surfaceContract({
@@ -9725,7 +10619,7 @@ var worktreesContracts = [
       module: "worktrees",
       functionName: "updateMetadata",
       kind: "mutation",
-      inputProjection: worktreeInput
+      inputProjection: worktreeMetadataInput
     }
   }),
   surfaceContract({
@@ -9741,12 +10635,17 @@ var worktreesContracts = [
       module: "worktrees",
       functionName: "complete",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...worktreeInput(input),
-        keyFindings: input.keyFindings ?? [input.summary ?? "Merged worktree"],
-        decisionsReached: input.decisionsReached ?? [],
-        nextSteps: input.nextSteps ?? []
-      })
+      inputProjection: (input, context) => withUserId(
+        {
+          ...worktreeIdInput(input),
+          keyFindings: input.keyFindings ?? [
+            input.summary ?? "Merged worktree"
+          ],
+          decisionsReached: input.decisionsReached ?? [],
+          nextSteps: input.nextSteps ?? []
+        },
+        context
+      )
     }
   }),
   surfaceContract({
@@ -9762,11 +10661,7 @@ var worktreesContracts = [
       module: "worktrees",
       functionName: "updateMetadata",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...worktreeInput(input),
-        lastPushTargetContext: input.targetContext,
-        lastPushBeliefIds: input.beliefIds
-      })
+      inputProjection: worktreeMetadataInput
     }
   }),
   surfaceContract({
@@ -9782,20 +10677,30 @@ var worktreesContracts = [
       module: "worktrees",
       functionName: "updateMetadata",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...worktreeInput(input),
-        lastPullRequestSummary: input.summary,
-        lastPullRequestReviewers: input.reviewers
-      })
+      inputProjection: worktreeMetadataInput
     }
   })
 ];
 
 // ../contracts/src/function-registry/tasks.ts
-var taskInput = (input) => ({
+var taskInput = (input) => compactRecord4({
   ...input,
   taskId: input.taskId ?? input.id
 });
+var taskTopicInput = (input) => {
+  const parsed = listTasksProjection.inputSchema.safeParse(input);
+  if (!parsed.success) {
+    throw new Error(
+      `list_tasks projection input rejected: ${parsed.error.message}`
+    );
+  }
+  return compactRecord4(listTasksProjection.project(parsed.data));
+};
+var completeTaskInput = (input) => compactRecord4({
+  taskId: input.taskId ?? input.id,
+  outputSummary: input.outputSummary ?? input.summary,
+  userId: input.userId
+});
 var tasksContracts = [
   surfaceContract({
     name: "create_task",
@@ -9825,8 +10730,10 @@ var tasksContracts = [
     convex: {
       module: "tasks",
       functionName: "getByTopic",
-      kind: "query"
-    }
+      kind: "query",
+      inputProjection: taskTopicInput
+    },
+    args: listTasksInputSchema
   }),
   surfaceContract({
     name: "update_task",
@@ -9858,12 +10765,29 @@ var tasksContracts = [
       module: "tasks",
       functionName: "complete",
       kind: "mutation",
-      inputProjection: taskInput
+      inputProjection: completeTaskInput
     }
   })
 ];
-
-// ../contracts/src/function-registry/edges.ts
+var createEdgeArgs = z.object({
+  from: GraphRefSchema,
+  to: GraphRefSchema,
+  edgeType: z.string(),
+  globalId: z.string().optional(),
+  weight: z.number().optional(),
+  confidence: z.number().optional(),
+  context: z.string().optional(),
+  reasoning: z.string().optional(),
+  derivationType: z.string().optional(),
+  topicId: z.string().optional(),
+  trustedBypassAccessCheck: z.boolean().optional()
+});
+function graphRefNodeId(ref) {
+  if (ref.kind === "epistemic_node") {
+    return ref.nodeId;
+  }
+  return `external_belief:${ref.ref.tenantId}:${ref.ref.beliefId}`;
+}
 var edgesContracts = [
   surfaceContract({
     name: "create_edge",
@@ -9878,16 +10802,35 @@ var edgesContracts = [
       module: "edges",
       functionName: "create",
       kind: "mutation",
-      inputProjection: (input, context) => withCreatedBy(
-        {
-          ...input,
-          fromNodeId: input.fromNodeId ?? input.sourceId,
-          toNodeId: input.toNodeId ?? input.targetId,
-          context: input.context ?? input.reasoning
-        },
-        context
-      )
-    }
+      inputProjection: (input, context) => {
+        const parsed = createEdgeArgs.parse(input);
+        assertEdgePolicyAllowed(
+          edgePolicyManifest,
+          parsed.edgeType,
+          parsed.from,
+          parsed.to
+        );
+        const fromNodeId = graphRefNodeId(parsed.from);
+        const toNodeId = graphRefNodeId(parsed.to);
+        return withCreatedBy(
+          compactRecord4({
+            fromNodeId,
+            toNodeId,
+            edgeType: parsed.edgeType,
+            globalId: parsed.globalId ?? `edge:${fromNodeId}:${toNodeId}:${parsed.edgeType}`,
+            weight: parsed.weight,
+            confidence: parsed.confidence,
+            context: parsed.context ?? parsed.reasoning,
+            derivationType: parsed.derivationType,
+            skipLayerValidation: true,
+            topicId: parsed.topicId,
+            trustedBypassAccessCheck: parsed.trustedBypassAccessCheck
+          }),
+          context
+        );
+      }
+    },
+    args: createEdgeArgs
   }),
   surfaceContract({
     name: "query_lineage",
@@ -9902,9 +10845,12 @@ var edgesContracts = [
       module: "edges",
       functionName: "getLineage",
       kind: "query",
-      inputProjection: (input) => ({
-        ...input,
-        maxDepth: input.maxDepth ?? input.depth
+      inputProjection: (input) => compactRecord4({
+        nodeId: input.nodeId ?? input.startNode,
+        maxDepth: input.maxDepth ?? input.depth,
+        mode: input.mode,
+        minLayer: input.minLayer,
+        maxLayer: input.maxLayer
       })
     }
   })
@@ -9924,8 +10870,7 @@ var contradictionSeverity = (value) => {
       return "significant";
   }
 };
-var flagContradictionInput = (input, context) => ({
-  ...input,
+var flagContradictionInput = (input, context) => compactRecord4({
   beliefId: input.beliefId ?? input.beliefA,
   supportingInsightIds: Array.isArray(input.supportingInsightIds) ? input.supportingInsightIds : [],
   contradictingInsightIds: Array.isArray(input.contradictingInsightIds) ? input.contradictingInsightIds : [input.beliefB].filter((value) => typeof value === "string"),
@@ -9939,6 +10884,18 @@ var flagContradictionInput = (input, context) => ({
   },
   createdBy: authUserId(context)
 });
+var lineageInput = (input) => compactRecord4({
+  nodeId: input.nodeId ?? input.startNode ?? input.entityId,
+  maxDepth: input.maxDepth ?? input.depth,
+  mode: input.mode,
+  minLayer: input.minLayer,
+  maxLayer: input.maxLayer
+});
+var topicEdgesInput = (input) => compactRecord4({
+  topicId: input.topicId,
+  userId: input.userId,
+  limit: input.limit
+});
 var graphContracts = [
   surfaceContract({
     name: "traverse_graph",
@@ -9952,7 +10909,8 @@ var graphContracts = [
     convex: {
       module: "edges",
       functionName: "getLineage",
-      kind: "query"
+      kind: "query",
+      inputProjection: lineageInput
     }
   }),
   surfaceContract({
@@ -9967,7 +10925,8 @@ var graphContracts = [
     convex: {
       module: "edges",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: topicEdgesInput
     }
   }),
   surfaceContract({
@@ -9997,7 +10956,10 @@ var graphContracts = [
     convex: {
       module: "edges",
       functionName: "findContradictions",
-      kind: "query"
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        nodeId: input.nodeId ?? input.beliefId
+      })
     }
   }),
   surfaceContract({
@@ -10102,8 +11064,9 @@ var graphContracts = [
     summary: "Discover graph connections for an entity.",
     convex: {
       module: "edges",
-      functionName: "getByTopic",
-      kind: "query"
+      functionName: "getLineage",
+      kind: "query",
+      inputProjection: lineageInput
     }
   }),
   surfaceContract({
@@ -10134,10 +11097,7 @@ var graphContracts = [
       module: "edges",
       functionName: "getLineage",
       kind: "query",
-      inputProjection: (input) => ({
-        ...input,
-        nodeId: input.nodeId ?? input.entityId
-      })
+      inputProjection: lineageInput
     }
   })
 ];
@@ -10207,19 +11167,21 @@ var judgmentsContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: (input, context) => withUserId(
-        {
-          ...input,
+        compactRecord4({
+          projectId: input.projectId,
+          topicId: input.topicId,
           text: input.rationale,
           title: input.title,
           content: input.rationale,
           kind: "judgment",
-          sourceType: "agent",
-          metadata: {
+          sourceType: "ai_generated",
+          metadata: compactRecord4({
             confidence: input.confidence,
             beliefIds: input.beliefIds
-          },
+          }),
+          rationale: input.rationale ?? input.reasoning ?? "Recorded judgment evidence",
           trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
-        },
+        }),
         context
       )
     }
@@ -10237,9 +11199,12 @@ var judgmentsContracts = [
       module: "edges",
       functionName: "getLineage",
       kind: "query",
-      inputProjection: (input) => ({
-        ...input,
-        nodeId: input.nodeId ?? input.id
+      inputProjection: (input) => compactRecord4({
+        nodeId: input.nodeId ?? input.id,
+        maxDepth: input.maxDepth ?? input.depth,
+        mode: input.mode,
+        minLayer: input.minLayer,
+        maxLayer: input.maxLayer
       })
     }
   })
@@ -10365,7 +11330,10 @@ var coordinationContracts = [
       module: "coordination",
       functionName: "getInbox",
       kind: "query",
-      injectSessionId: "sessionId"
+      injectSessionId: "sessionId",
+      inputProjection: (input) => compactRecord4({
+        limit: input.limit
+      })
     }
   }),
   surfaceContract({
@@ -10383,7 +11351,6 @@ var coordinationContracts = [
       kind: "mutation",
       injectSessionId: "sessionId",
       inputProjection: (input) => ({
-        ...input,
         touchedFiles: stringArray(input.touchedFiles) ?? stringArray(input.files) ?? stringArray(input.paths) ?? []
       })
     }
@@ -10400,7 +11367,10 @@ var coordinationContracts = [
     convex: {
       module: "worktrees",
       functionName: "get",
-      kind: "query"
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        worktreeId: input.worktreeId ?? input.id
+      })
     }
   })
 ];
@@ -10419,7 +11389,13 @@ var pipelineContracts = [
     convex: {
       module: "worktrees",
       functionName: "listAll",
-      kind: "query"
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        status: input.status,
+        lane: input.lane,
+        campaign: input.campaign,
+        limit: input.limit
+      })
     }
   }),
   surfaceContract({
@@ -10469,43 +11445,63 @@ var recordScopeLearningArgs = z.object({
   linkedBeliefNodeId: z.string().optional().describe("Optional belief to attach evidence to"),
   evidenceRelation: z.enum(["supports", "contradicts"]).optional().describe("Relation to linked belief"),
   confidence: z.number().optional().describe("Optional confidence in [0,1]"),
+  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")
 });
-var learningInput = (input, context) => withUserId(
-  {
-    ...input,
-    text: input.summary ?? input.text,
-    title: input.title ?? input.summary ?? "Scope learning",
-    content: input.body ?? input.content ?? input.summary,
-    kind: input.kind ?? input.sourceKind ?? "learning",
-    tags: input.tags ?? [],
-    metadata: {
-      sourceRef: input.sourceRef,
-      sourceKind: input.sourceKind,
-      touchedPaths: input.touchedPaths
-    },
-    trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
-  },
-  context
-);
+var learningInput = (input, context) => {
+  const sourceKind = input.sourceKind ?? input.externalSourceType;
+  return withUserId(
+    compactRecord4({
+      projectId: input.projectId,
+      topicId: input.topicId,
+      text: input.summary ?? input.text,
+      title: input.title ?? input.summary ?? "Scope learning",
+      content: input.body ?? input.content ?? input.summary,
+      contentType: input.contentType,
+      kind: input.kind ?? "learning",
+      tags: input.tags ?? [],
+      sourceType: input.sourceType,
+      externalSourceType: input.externalSourceType ?? input.sourceKind,
+      sourceUrl: input.sourceUrl,
+      metadata: compactRecord4({
+        ...recordValue2(input.metadata),
+        sourceRef: input.sourceRef,
+        sourceKind,
+        touchedPaths: input.touchedPaths,
+        createQuestionText: input.createQuestionText,
+        createBeliefText: input.createBeliefText,
+        beliefType: input.beliefType
+      }),
+      linkedBeliefNodeId: input.linkedBeliefNodeId,
+      evidenceRelation: input.evidenceRelation,
+      confidence: input.confidence,
+      rationale: input.rationale ?? input.reasoning ?? input.summary ?? input.text ?? "Recorded scope learning",
+      trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
+    }),
+    context
+  );
+};
 var attemptInput = (input, context) => withUserId(
-  {
-    ...input,
+  compactRecord4({
+    projectId: input.projectId,
+    topicId: input.topicId,
     text: input.description,
     title: input.title ?? input.description,
     content: input.errorMessage ?? input.description,
     kind: "code_attempt",
     tags: ["code_attempt"],
-    metadata: {
+    metadata: compactRecord4({
+      ...recordValue2(input.metadata),
       filePaths: input.filePaths,
       filePath: input.filePath,
       errorMessage: input.errorMessage,
       linkedBeliefId: input.linkedBeliefId
-    },
+    }),
+    rationale: input.rationale ?? input.reasoning ?? input.errorMessage ?? input.description ?? "Recorded implementation attempt",
     trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
-  },
+  }),
   context
 );
 var codingContracts = [
@@ -10562,7 +11558,13 @@ var codingContracts = [
     convex: {
       module: "evidence",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        topicId: input.topicId,
+        limit: input.limit,
+        status: input.status,
+        userId: input.userId
+      })
     }
   }),
   surfaceContract({
@@ -10577,7 +11579,13 @@ var codingContracts = [
     convex: {
       module: "evidence",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        topicId: input.topicId,
+        limit: input.limit,
+        status: input.status,
+        userId: input.userId
+      })
     }
   }),
   surfaceContract({
@@ -10609,9 +11617,11 @@ var codingContracts = [
       module: "evidence",
       functionName: "getByTopic",
       kind: "query",
-      inputProjection: (input) => ({
-        ...input,
-        topicId: input.topicId ?? input.query
+      inputProjection: (input) => compactRecord4({
+        topicId: input.topicId ?? input.query,
+        limit: input.limit,
+        status: input.status,
+        userId: input.userId
       })
     }
   })
@@ -10671,11 +11681,124 @@ new Map(
 var ROOT_TOPIC_ID = "n17tm38rwet7wqgzrmwahyt1z582590y";
 
 // ../server-core/src/kernelApi.ts
+var REQUIRED_KERNEL_API_REF_SUFFIXES = [
+  "contradictions.create",
+  "contradictions.getById",
+  "contradictions.getByTopic",
+  "epistemicAnswers.create",
+  "epistemicAnswers.getLatestForQuestion",
+  "epistemicBeliefs.archive",
+  "epistemicBeliefs.batchUpdateCriticality",
+  "epistemicBeliefs.create",
+  "epistemicBeliefs.forkBelief",
+  "epistemicBeliefs.getById",
+  "epistemicBeliefs.getByTopic",
+  "epistemicBeliefs.getConfidenceHistory",
+  "epistemicBeliefs.getLineage",
+  "epistemicBeliefs.getRelationships",
+  "epistemicBeliefs.linkBeliefs",
+  "epistemicBeliefs.linkEvidence",
+  "epistemicBeliefs.modulateConfidence",
+  "epistemicBeliefs.reassignBeliefsTopic",
+  "epistemicBeliefs.refineBelief",
+  "epistemicBeliefs.unlinkEvidence",
+  "epistemicBeliefs.updateCriticality",
+  "epistemicBeliefs.updateRationale",
+  "epistemicBeliefs.updateStatus",
+  "epistemicContracts.createEpistemicContract",
+  "epistemicContracts.evaluateContract",
+  "epistemicContracts.getContractStatus",
+  "epistemicEdges.batchCreate",
+  "epistemicEdges.create",
+  "epistemicEdges.deleteEdges",
+  "epistemicEdges.getBySourceNode",
+  "epistemicEdges.getByTopicAndType",
+  "epistemicEdges.remove",
+  "epistemicEdges.removeBetween",
+  "epistemicEdges.update",
+  "epistemicEvidence.create",
+  "epistemicEvidence.flagAsIncorrect",
+  "epistemicEvidence.getById",
+  "epistemicEvidence.getByTopic",
+  "epistemicEvidence.getForBelief",
+  "epistemicEvidence.remove",
+  "epistemicEvidence.update",
+  "epistemicEvidence.updateStatus",
+  "epistemicEvidence.updateVerificationStatus",
+  "epistemicNodes.get",
+  "epistemicNodes.getByGlobalId",
+  "epistemicQuestions.addQuestion",
+  "epistemicQuestions.advanceToConviction",
+  "epistemicQuestions.create",
+  "epistemicQuestions.createBatch",
+  "epistemicQuestions.deleteQuestion",
+  "epistemicQuestions.finalizeConviction",
+  "epistemicQuestions.getById",
+  "epistemicQuestions.getByTopic",
+  "epistemicQuestions.internalCreate",
+  "epistemicQuestions.updateConviction",
+  "epistemicQuestions.updatePriority",
+  "epistemicQuestions.updateQuestion",
+  "epistemicQuestions.updateStatus",
+  "evidenceClassifier.classifyEvidence",
+  "evidenceClassifier.classifyEvidenceBatch",
+  "graphAnalysisCache.getCachedAnalysis",
+  "graphIntelligence.analyzeProject",
+  "neo4jEdgeAPI.getGraphNeighborhood",
+  "neo4jQueries.getConfirmationBiasScore",
+  "ontologyDefinitions.archiveOntologyDefinition",
+  "ontologyDefinitions.createOntologyDefinition",
+  "ontologyDefinitions.createOntologyVersion",
+  "ontologyDefinitions.deprecateOntologyVersion",
+  "ontologyDefinitions.getOntologyDefinition",
+  "ontologyDefinitions.getOntologyDefinitionByKey",
+  "ontologyDefinitions.getPublishedVersion",
+  "ontologyDefinitions.listOntologyDefinitions",
+  "ontologyDefinitions.publishOntologyVersion",
+  "ontologyDefinitions.resolveEffectiveOntology",
+  "ontologyDefinitions.updateOntologyDefinition",
+  "policy.filterByPermission",
+  "questionEvidenceLinks.create",
+  "questionEvidenceLinks.getEvidenceWithDetails",
+  "tasks.complete",
+  "tasks.create",
+  "tasks.get",
+  "tasks.getByTopic",
+  "tasks.getByWorktree",
+  "tasks.update",
+  "topics.bulkCreate",
+  "topics.checkAccess",
+  "topics.create",
+  "topics.get",
+  "topics.getTree",
+  "topics.list",
+  "topics.listByOntology",
+  "topics.remove",
+  "topics.resolveTopicOntology",
+  "topics.update",
+  "worktrees.activate",
+  "worktrees.advancePhase",
+  "worktrees.bulkCreate",
+  "worktrees.complete",
+  "worktrees.create",
+  "worktrees.get",
+  "worktrees.list",
+  "worktrees.listAll",
+  "worktrees.patchState",
+  "worktrees.setPhase",
+  "worktrees.updateMetadata",
+  "worktrees.updateTargets"
+];
+var KERNEL_API_REF_MANIFEST = REQUIRED_KERNEL_API_REF_SUFFIXES.map((path3) => ({
+  path: `api.${path3}`,
+  componentPath: `components.lucern.${path3}`
+}));
 var GLOBAL_KEY = "__LUCERN_SERVER_CORE_KERNEL_API_BINDING__";
 function store() {
   return globalThis;
 }
 function registerKernelApi(nextBinding) {
+  assertKernelApiBinding(nextBinding);
   store()[GLOBAL_KEY] = nextBinding;
 }
 function getBinding() {
@@ -10687,10 +11810,55 @@ function getBinding() {
   }
   return current;
 }
-function makeProxy(which) {
+function readPath(root, path3) {
+  let cursor = root;
+  for (const part of path3) {
+    if (cursor == null || typeof cursor !== "object") {
+      return void 0;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function resolveApiPath(binding, which, path3) {
+  return readPath(binding[which], path3);
+}
+function validateKernelApiBinding(binding) {
+  const missing = [];
+  const resolved = [];
+  for (const entry of KERNEL_API_REF_MANIFEST) {
+    const suffix = entry.path.split(".").slice(1);
+    const reference = resolveApiPath(binding, "api", suffix);
+    if (reference === void 0) {
+      missing.push(entry);
+    } else {
+      resolved.push(entry);
+    }
+  }
+  return {
+    ok: missing.length === 0,
+    missing,
+    resolved
+  };
+}
+function assertKernelApiBinding(binding) {
+  const result = validateKernelApiBinding(binding);
+  if (!result.ok) {
+    const refs = result.missing.map((entry) => entry.path).join(", ");
+    throw new Error(
+      `Server-core kernelApi binding is missing required refs: ${refs}`
+    );
+  }
+}
+function makeProxy(which, path3 = []) {
   return new Proxy({}, {
     get(_target, prop) {
-      return getBinding()[which][prop];
+      if (typeof prop !== "string") {
+        return void 0;
+      }
+      const nextPath = [...path3, prop];
+      const resolved = resolveApiPath(getBinding(), which, nextPath);
+      return resolved === void 0 ? makeProxy(which, nextPath) : resolved;
     }
   });
 }
@@ -10794,10 +11962,7 @@ async function resolveMutationRuntimeFields(toolName) {
   let cached = mutationRuntimeCache.get(normalizedToolName);
   if (!cached) {
     cached = (async () => {
-      const tools = await getLucernClient().query(
-        api2.toolAccess.getExecutableTools,
-        {}
-      );
+      const tools = await adminQuery("toolAccess:listToolRegistry", {});
       const tool = tools.find(
         (candidate) => candidate?.toolName === normalizedToolName && candidate?.isActive !== false && candidate?.status !== "deprecated" && candidate?.status !== "disabled"
       );
@@ -10915,7 +12080,7 @@ async function tryGetTopicById(topicId) {
 }
 async function tryGetNodeById(nodeId) {
   try {
-    const node = await adminQuery(components2.lucern.epistemicNodes.getInternal, {
+    const node = await adminQuery(api2.epistemicNodes.getInternal, {
       nodeId
     });
     return node || null;
@@ -11002,10 +12167,10 @@ function readOpinionTuple(args) {
     );
   }
   return {
-    b: belief ?? 0,
-    d: disbelief ?? 0,
-    u: uncertainty ?? 0,
-    a: baseRate ?? 0.5
+    b: belief,
+    d: disbelief,
+    u: uncertainty,
+    a: baseRate
   };
 }
 var beliefHandlers = {
@@ -11073,6 +12238,11 @@ var beliefHandlers = {
           opinion,
           trigger: readString(args.trigger),
           rationale: readString(args.rationale) ?? "",
+          triggeringEvidenceId: readString(args.triggeringEvidenceId),
+          triggeringQuestionId: readString(args.triggeringQuestionId),
+          triggeringAnswerId: readString(args.triggeringAnswerId),
+          triggeringContradictionId: readString(args.triggeringContradictionId),
+          triggeringWorktreeId: readString(args.triggeringWorktreeId),
           maxInlinePropagationTargets: readNumber(
             args.maxInlinePropagationTargets
           )
@@ -11161,7 +12331,7 @@ async function resolveBeliefs(nodeIds) {
   const results = [];
   for (const nodeId of nodeIds) {
     try {
-      const node = await adminQuery(components2.lucern.epistemicNodes.get, {
+      const node = await adminQuery(api2.epistemicNodes.get, {
         nodeId
       });
       if (!node) {
@@ -11181,7 +12351,7 @@ async function resolveQuestions(nodeIds) {
   const results = [];
   for (const nodeId of nodeIds) {
     try {
-      const node = await adminQuery(components2.lucern.epistemicNodes.get, {
+      const node = await adminQuery(api2.epistemicNodes.get, {
         nodeId
       });
       if (!node) {
@@ -11217,9 +12387,10 @@ async function beginBuildSession(args) {
   }
   const worktreeName = String(worktree.name || "Untitled");
   const topicId = String(worktree.topicId || "");
-  const track = String(worktree.track || "untracked");
-  const trackPosition = worktree.trackPosition ?? 0;
-  const executionBand = worktree.executionBand ?? 0;
+  const campaign = typeof worktree.campaign === "number" ? worktree.campaign : null;
+  const lane = String(worktree.lane || "unlaned");
+  const laneOrderInCampaign = typeof worktree.laneOrderInCampaign === "number" ? worktree.laneOrderInCampaign : null;
+  const orderInLane = typeof worktree.orderInLane === "number" ? worktree.orderInLane : null;
   const gate = String(worktree.gate || "");
   const hypothesis = String(worktree.hypothesis || worktree.beliefFocus || "");
   let status = String(worktree.status || "planning");
@@ -11269,7 +12440,7 @@ async function beginBuildSession(args) {
         }
       } catch {
         try {
-          const node = await adminQuery(components2.lucern.epistemicNodes.get, {
+          const node = await adminQuery(api2.epistemicNodes.get, {
             nodeId: question.nodeId
           });
           if (node?._id) {
@@ -11301,7 +12472,7 @@ async function beginBuildSession(args) {
     });
   }
   try {
-    const topicQuestions = await adminQuery(components2.lucern.epistemicQuestions.getByTopic, {
+    const topicQuestions = await adminQuery(api2.epistemicQuestions.getByTopic, {
       topicId,
       userId: "system",
       limit: 20
@@ -11435,9 +12606,10 @@ async function beginBuildSession(args) {
     branch: effectiveBranch,
     branchBase,
     prBase,
-    track,
-    trackPosition,
-    executionBand,
+    campaign,
+    lane,
+    laneOrderInCampaign,
+    orderInLane,
     gate,
     hypothesis,
     focus,
@@ -12469,6 +13641,14 @@ var generatedFunctionSurfaceHandlers = {
       )
     );
   },
+  async list_campaigns(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).raw.functionSurface.listCampaigns(
+        stripInternalArgs(args),
+        idempotencyKeyFrom(args)
+      )
+    );
+  },
   async list_evidence(args, ctx) {
     return formatSdkResult(
       await getSdkClient(ctx).raw.functionSurface.listEvidence(
@@ -13846,7 +15026,7 @@ var researchVerificationHandlers = {
   async evaluate_research_contract(args, ctx) {
     const inputData = buildInputData(args);
     const result = await adminMutation(
-      api2.epistemicContracts.evaluateContractsForTrigger,
+      api2.contracts.evaluateContractsForTrigger,
       {
         beliefNodeId: args.beliefNodeId,
         trigger: typeof args.trigger === "string" && args.trigger.length > 0 ? args.trigger : "event_driven",
@@ -14146,7 +15326,7 @@ var worktreeHandlers = {
       summary: objective ?? hypothesis ?? title,
       tags: [
         ...readStringArray(args.tags) ?? [],
-        ...readString(args.track) ? [readString(args.track)] : [],
+        ...readString(args.lane) ? [readString(args.lane)] : [],
         ...readString(args.gate) ? [readString(args.gate)] : []
       ],
       sourceRef: title,
@@ -14161,7 +15341,10 @@ var worktreeHandlers = {
         beliefIds: readStringArray(args.beliefIds) ?? readStringArray(args.beliefs),
         autoShape: typeof args.autoShape === "boolean" ? args.autoShape : void 0,
         domainPackId: readString(args.domainPackId),
-        executionOrder: readNumber(args.executionOrder),
+        campaign: readNumber(args.campaign),
+        lane: readString(args.lane),
+        laneOrderInCampaign: readNumber(args.laneOrderInCampaign),
+        orderInLane: readNumber(args.orderInLane),
         dependsOn: readStringArray(args.dependsOn),
         blocks: readStringArray(args.blocks),
         gate: readString(args.gate),
@@ -14177,6 +15360,18 @@ var worktreeHandlers = {
       await getSdkClient(ctx).worktrees.list({
         topicId: readString(args.topicId ?? args.projectId) ?? "",
         status: readString(args.status),
+        groupBy: readString(args.groupBy),
+        lane: readString(args.lane),
+        campaign: readNumber(args.campaign),
+        limit: readNumber(args.limit)
+      })
+    );
+  },
+  async list_campaigns(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.listCampaigns({
+        topicId: readString(args.topicId ?? args.projectId),
+        status: readString(args.status),
         limit: readNumber(args.limit)
       })
     );
@@ -14195,10 +15390,10 @@ var worktreeHandlers = {
         objective: readString(args.objective),
         hypothesis: readString(args.hypothesis),
         rationale: readString(args.rationale),
-        track: readString(args.track),
-        trackPosition: readNumber(args.trackPosition),
-        executionBand: readNumber(args.executionBand),
-        executionOrder: readNumber(args.executionOrder),
+        campaign: readNumber(args.campaign),
+        lane: readString(args.lane),
+        laneOrderInCampaign: readNumber(args.laneOrderInCampaign),
+        orderInLane: readNumber(args.orderInLane),
         dependsOn: readStringArray(args.dependsOn),
         blocks: readStringArray(args.blocks),
         gate: readString(args.gate),
@@ -14236,8 +15431,9 @@ var worktreeHandlers = {
     return formatSdkResult(
       await getSdkClient(ctx).worktrees.listAll({
         status: readString(args.status),
-        track: readString(args.track),
-        executionBand: readNumber(args.executionBand),
+        lane: readString(args.lane),
+        campaign: readNumber(args.campaign),
+        groupBy: readString(args.groupBy),
         limit: readNumber(args.limit)
       })
     );
@@ -14427,7 +15623,7 @@ async function checkWritePolicy(toolName, topicId, authCtx) {
     return { allowed: true, permission: "allow", reason: "read_only_tool" };
   }
   try {
-    const result = await adminQuery(api2.mcpWritePolicy.checkAccess, {
+    const result = await adminQuery("mcpWritePolicy:checkAccess", {
       topicId: topicId ?? void 0,
       role: authCtx.role,
       toolName