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

package/dist/gateway.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { v } from 'convex/values';
 import { basename, extname } from 'path';
 import { randomUUID } from 'crypto';
 
@@ -445,6 +446,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",
@@ -514,9 +537,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(),
@@ -525,10 +548,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(),
@@ -1211,7 +1236,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(),
@@ -3880,13 +3905,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(),
@@ -4134,10 +4159,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-workflow.contract.ts
 var LENS_PERSPECTIVE_TYPES = [
@@ -4151,7 +4635,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",
@@ -4163,7 +4647,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",
@@ -4174,7 +4658,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: {
@@ -4237,7 +4721,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: {
@@ -4256,9 +4740,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",
@@ -4273,17 +4757,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: {
@@ -4477,7 +4987,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: {
@@ -4558,9 +5068,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",
@@ -5218,6 +5740,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: {
@@ -5226,7 +5752,7 @@ var CREATE_EVIDENCE = {
     },
     kind: { type: "string", description: "Optional evidence kind" }
   },
-  required: ["text"],
+  required: ["text", "rationale"],
   response: {
     description: "The created canonical evidence record",
     fields: {
@@ -5274,7 +5800,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: {
@@ -5459,6 +5985,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",
@@ -5471,7 +5998,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: {
@@ -5690,6 +6217,10 @@ var LIST_BELIEFS = {
     minConfidence: {
       type: "number",
       description: "Minimum confidence threshold"
+    },
+    limit: {
+      type: "number",
+      description: "Maximum results"
     }
   },
   required: ["topicId"],
@@ -5706,20 +6237,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",
@@ -5728,7 +6276,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",
@@ -5746,13 +6294,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",
@@ -5763,10 +6316,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",
@@ -5829,16 +6411,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",
@@ -5876,18 +6470,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.",
@@ -6257,6 +6839,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",
@@ -6344,7 +6930,7 @@ var GET_TOPIC = {
       description: "Legacy alias for topicId"
     }
   },
-  required: [],
+  required: ["topicId"],
   response: {
     description: "Single topic record",
     fields: {
@@ -6699,7 +7285,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: {
@@ -6766,7 +7352,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: {
@@ -7020,7 +7606,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" }
   },
@@ -7030,14 +7616,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",
@@ -7626,6 +8212,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,
@@ -7808,6 +8395,7 @@ var MCP_WORKFLOW_PLATFORM_OPERATION_NAMES = [
   "activate_worktree",
   "list_worktrees",
   "list_all_worktrees",
+  "list_campaigns",
   "update_worktree_targets",
   "update_worktree_metadata",
   "create_task",
@@ -8015,6 +8603,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(
@@ -8049,10 +8638,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) {
@@ -8073,6 +8692,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 };
     }
@@ -8092,6 +8714,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 {
@@ -8153,6 +8776,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) {
@@ -8197,7 +8828,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,
@@ -8259,20 +8892,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 = [
@@ -8324,7 +8963,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
+      })
     }
   })
 ];
@@ -8390,42 +9035,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
   );
 };
@@ -8460,7 +9125,7 @@ var beliefsContracts = [
       module: "beliefs",
       functionName: "getById",
       kind: "query",
-      inputProjection: withBeliefId
+      inputProjection: beliefLookupInput
     }
   }),
   surfaceContract({
@@ -8476,8 +9141,10 @@ var beliefsContracts = [
     convex: {
       module: "beliefs",
       functionName: "getByTopic",
-      kind: "query"
-    }
+      kind: "query",
+      inputProjection: beliefTopicInput
+    },
+    args: listBeliefsInputSchema
   }),
   surfaceContract({
     name: "refine_belief",
@@ -8495,7 +9162,7 @@ var beliefsContracts = [
       kind: "mutation",
       inputProjection: (input, context) => withUserId(
         {
-          ...withBeliefId(input),
+          ...beliefLookupInput(input),
           trustedBypassAccessCheck: input.trustedBypassAccessCheck ?? true
         },
         context
@@ -8516,7 +9183,8 @@ var beliefsContracts = [
       functionName: "modulateConfidence",
       kind: "mutation",
       inputProjection: confidenceInput
-    }
+    },
+    args: modulateConfidenceInputSchema
   }),
   surfaceContract({
     name: "fork_belief",
@@ -8549,10 +9217,10 @@ var beliefsContracts = [
       functionName: "archive",
       kind: "mutation",
       inputProjection: (input, context) => withUserId(
-        {
-          ...withBeliefId(input),
+        compactRecord4({
+          ...beliefNodeInput(input),
           reason: input.reason ?? input.rationale
-        },
+        }),
         context
       )
     }
@@ -8570,10 +9238,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
       })
     }
   }),
@@ -8590,7 +9260,7 @@ var beliefsContracts = [
       module: "beliefs",
       functionName: "getConfidenceHistory",
       kind: "query",
-      inputProjection: withBeliefId
+      inputProjection: beliefNodeInput
     }
   }),
   surfaceContract({
@@ -8607,25 +9277,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 = [
@@ -8669,8 +9383,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
             }
@@ -8710,7 +9425,8 @@ var evidenceContracts = [
     convex: {
       module: "evidence",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: evidenceTopicInput
     }
   }),
   surfaceContract({
@@ -8726,10 +9442,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
       })
     }
   }),
@@ -8743,17 +9461,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({
@@ -8766,18 +9477,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({
@@ -8790,35 +9493,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",
@@ -8850,7 +9564,7 @@ var questionsContracts = [
       module: "questions",
       functionName: "getById",
       kind: "query",
-      inputProjection: questionIdInput
+      inputProjection: questionNodeInput
     }
   }),
   surfaceContract({
@@ -8866,7 +9580,8 @@ var questionsContracts = [
     convex: {
       module: "questions",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: questionTopicInput
     }
   }),
   surfaceContract({
@@ -8883,7 +9598,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({
@@ -8900,7 +9620,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({
@@ -8917,7 +9646,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({
@@ -8934,10 +9668,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
       )
     }
@@ -8957,13 +9697,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
       )
     }
@@ -8996,7 +9739,8 @@ var questionsContracts = [
     convex: {
       module: "questions",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: questionTopicInput
     }
   }),
   surfaceContract({
@@ -9011,7 +9755,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({
@@ -9026,16 +9774,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",
@@ -9100,7 +9860,7 @@ var topicsContracts = [
       module: "topics",
       functionName: "update",
       kind: "mutation",
-      inputProjection: topicIdInput
+      inputProjection: updateTopicInput
     }
   }),
   surfaceContract({
@@ -9122,6 +9882,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",
@@ -9135,7 +9916,8 @@ var lensesContracts = [
     convex: {
       module: "lenses",
       functionName: "create",
-      kind: "mutation"
+      kind: "mutation",
+      inputProjection: createLensInput
     }
   }),
   surfaceContract({
@@ -9151,7 +9933,8 @@ var lensesContracts = [
     convex: {
       module: "lenses",
       functionName: "list",
-      kind: "query"
+      kind: "query",
+      inputProjection: lensListInput
     }
   }),
   surfaceContract({
@@ -9166,7 +9949,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({
@@ -9182,12 +9971,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",
@@ -9218,10 +10023,7 @@ var ontologiesContracts = [
       module: "ontologies",
       functionName: "getOntologyDefinition",
       kind: "query",
-      inputProjection: (input) => ({
-        ...input,
-        id: input.id ?? input.ontologyId
-      })
+      inputProjection: ontologyIdInput
     }
   }),
   surfaceContract({
@@ -9254,9 +10056,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
       })
     }
   }),
@@ -9274,10 +10080,7 @@ var ontologiesContracts = [
       module: "ontologies",
       functionName: "archiveOntologyDefinition",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...input,
-        id: input.id ?? input.ontologyId
-      })
+      inputProjection: ontologyIdInput
     }
   }),
   surfaceContract({
@@ -9308,8 +10111,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
       })
@@ -9327,7 +10129,8 @@ var ontologiesContracts = [
     convex: {
       module: "ontologies",
       functionName: "resolveEffectiveOntology",
-      kind: "query"
+      kind: "query",
+      inputProjection: effectiveOntologyInput
     }
   }),
   surfaceContract({
@@ -9343,10 +10146,7 @@ var ontologiesContracts = [
       module: "ontologies",
       functionName: "publishOntologyVersion",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...input,
-        id: input.id ?? input.versionId
-      })
+      inputProjection: ontologyVersionIdInput
     }
   }),
   surfaceContract({
@@ -9362,10 +10162,7 @@ var ontologiesContracts = [
       module: "ontologies",
       functionName: "deprecateOntologyVersion",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...input,
-        id: input.id ?? input.versionId
-      })
+      inputProjection: ontologyVersionIdInput
     }
   }),
   surfaceContract({
@@ -9380,16 +10177,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",
@@ -9405,11 +10237,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
       )
     }
@@ -9427,7 +10291,7 @@ var worktreesContracts = [
       module: "worktrees",
       functionName: "activate",
       kind: "mutation",
-      inputProjection: worktreeInput
+      inputProjection: activateWorktreeInput
     }
   }),
   surfaceContract({
@@ -9443,7 +10307,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({
@@ -9459,7 +10352,8 @@ var worktreesContracts = [
     convex: {
       module: "worktrees",
       functionName: "listAll",
-      kind: "query"
+      kind: "query",
+      inputProjection: listAllWorktreesInput
     }
   }),
   surfaceContract({
@@ -9476,7 +10370,7 @@ var worktreesContracts = [
       module: "worktrees",
       functionName: "updateTargets",
       kind: "mutation",
-      inputProjection: worktreeInput
+      inputProjection: worktreeTargetsInput
     }
   }),
   surfaceContract({
@@ -9493,7 +10387,7 @@ var worktreesContracts = [
       module: "worktrees",
       functionName: "updateMetadata",
       kind: "mutation",
-      inputProjection: worktreeInput
+      inputProjection: worktreeMetadataInput
     }
   }),
   surfaceContract({
@@ -9509,12 +10403,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({
@@ -9530,11 +10429,7 @@ var worktreesContracts = [
       module: "worktrees",
       functionName: "updateMetadata",
       kind: "mutation",
-      inputProjection: (input) => ({
-        ...worktreeInput(input),
-        lastPushTargetContext: input.targetContext,
-        lastPushBeliefIds: input.beliefIds
-      })
+      inputProjection: worktreeMetadataInput
     }
   }),
   surfaceContract({
@@ -9550,20 +10445,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",
@@ -9593,8 +10498,10 @@ var tasksContracts = [
     convex: {
       module: "tasks",
       functionName: "getByTopic",
-      kind: "query"
-    }
+      kind: "query",
+      inputProjection: taskTopicInput
+    },
+    args: listTasksInputSchema
   }),
   surfaceContract({
     name: "update_task",
@@ -9626,12 +10533,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",
@@ -9646,16 +10570,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",
@@ -9670,9 +10613,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
       })
     }
   })
@@ -9692,8 +10638,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"),
@@ -9707,6 +10652,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",
@@ -9720,7 +10677,8 @@ var graphContracts = [
     convex: {
       module: "edges",
       functionName: "getLineage",
-      kind: "query"
+      kind: "query",
+      inputProjection: lineageInput
     }
   }),
   surfaceContract({
@@ -9735,7 +10693,8 @@ var graphContracts = [
     convex: {
       module: "edges",
       functionName: "getByTopic",
-      kind: "query"
+      kind: "query",
+      inputProjection: topicEdgesInput
     }
   }),
   surfaceContract({
@@ -9765,7 +10724,10 @@ var graphContracts = [
     convex: {
       module: "edges",
       functionName: "findContradictions",
-      kind: "query"
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        nodeId: input.nodeId ?? input.beliefId
+      })
     }
   }),
   surfaceContract({
@@ -9870,8 +10832,9 @@ var graphContracts = [
     summary: "Discover graph connections for an entity.",
     convex: {
       module: "edges",
-      functionName: "getByTopic",
-      kind: "query"
+      functionName: "getLineage",
+      kind: "query",
+      inputProjection: lineageInput
     }
   }),
   surfaceContract({
@@ -9902,10 +10865,7 @@ var graphContracts = [
       module: "edges",
       functionName: "getLineage",
       kind: "query",
-      inputProjection: (input) => ({
-        ...input,
-        nodeId: input.nodeId ?? input.entityId
-      })
+      inputProjection: lineageInput
     }
   })
 ];
@@ -9975,19 +10935,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
       )
     }
@@ -10005,9 +10967,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
       })
     }
   })
@@ -10133,7 +11098,10 @@ var coordinationContracts = [
       module: "coordination",
       functionName: "getInbox",
       kind: "query",
-      injectSessionId: "sessionId"
+      injectSessionId: "sessionId",
+      inputProjection: (input) => compactRecord4({
+        limit: input.limit
+      })
     }
   }),
   surfaceContract({
@@ -10151,7 +11119,6 @@ var coordinationContracts = [
       kind: "mutation",
       injectSessionId: "sessionId",
       inputProjection: (input) => ({
-        ...input,
         touchedFiles: stringArray(input.touchedFiles) ?? stringArray(input.files) ?? stringArray(input.paths) ?? []
       })
     }
@@ -10168,7 +11135,10 @@ var coordinationContracts = [
     convex: {
       module: "worktrees",
       functionName: "get",
-      kind: "query"
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        worktreeId: input.worktreeId ?? input.id
+      })
     }
   })
 ];
@@ -10187,7 +11157,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({
@@ -10237,43 +11213,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 = [
@@ -10330,7 +11326,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({
@@ -10345,7 +11347,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({
@@ -10377,9 +11385,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
       })
     }
   })
@@ -10926,8 +11936,6 @@ function errorResponse(args) {
     }
   );
 }
-
-// ../server-core/src/kernelApi.ts
 var GLOBAL_KEY = "__LUCERN_SERVER_CORE_KERNEL_API_BINDING__";
 function store() {
   return globalThis;
@@ -10941,10 +11949,28 @@ function getBinding() {
   }
   return current;
 }
-function makeProxy(which) {
+function readPath(root, path) {
+  let cursor = root;
+  for (const part of path) {
+    if (cursor == null || typeof cursor !== "object") {
+      return void 0;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function resolveApiPath(binding, which, path) {
+  return readPath(binding[which], path);
+}
+function makeProxy(which, path = []) {
   return new Proxy({}, {
     get(_target, prop) {
-      return getBinding()[which][prop];
+      if (typeof prop !== "string") {
+        return void 0;
+      }
+      const nextPath = [...path, prop];
+      const resolved = resolveApiPath(getBinding(), which, nextPath);
+      return resolved === void 0 ? makeProxy(which, nextPath) : resolved;
     }
   });
 }
@@ -10969,6 +11995,7 @@ var allowAlwaysPolicy = {
 };
 
 // ../server-core/src/domain/beliefs.ts
+var DEFAULT_BELIEF_BASE_RATE = 0.5;
 function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -11006,17 +12033,8 @@ function normalizeRequiredString(value, field) {
   }
   return normalized;
 }
-function normalizeRequiredBaseRate(value) {
-  const baseRate = readNumber(value);
-  if (baseRate === void 0) {
-    throwBeliefsError({
-      message: "[beliefs] baseRate is required.",
-      status: 400,
-      code: "INVALID_REQUEST",
-      invariantCode: "request.valid_shape",
-      suggestion: "Provide baseRate in the request payload."
-    });
-  }
+function normalizeBaseRate(value) {
+  const baseRate = readNumber(value) ?? DEFAULT_BELIEF_BASE_RATE;
   validateOpinionComponent(baseRate, "baseRate");
   return baseRate;
 }
@@ -11093,18 +12111,21 @@ function normalizeConfidenceTrigger(value) {
     case "evidence_removed":
     case "contradiction_detected":
     case "contradiction_resolved":
-    case "manual":
-    case "decay":
     case "agent_assessment":
     case "worktree_outcome":
     case "worktree_completed":
     case "fusion":
     case "discount":
     case "deduction":
-    case "backfill_synthetic":
       return normalized;
     default:
-      return "manual";
+      throwBeliefsError({
+        message: "[beliefs] trigger must name an evidence-bearing cause.",
+        status: 400,
+        code: "INVALID_REQUEST",
+        invariantCode: "belief.confidence_append_only",
+        suggestion: "Use evidence_added, evidence_removed, contradiction_detected, contradiction_resolved, agent_assessment, worktree_outcome, worktree_completed, fusion, discount, or deduction."
+      });
   }
 }
 function normalizeConditionType(value) {
@@ -11273,12 +12294,17 @@ function normalizeHistoryEntry(value) {
     opinion.a = baseRate;
   }
   const triggeringEvidenceRawId = readString(record.triggeringEvidenceId) ?? readStringArray(record.triggeringEvidenceIds)?.[0];
+  const triggeringQuestionRawId = readString(record.triggeringQuestionId);
+  const triggeringAnswerRawId = readString(record.triggeringAnswerId);
+  const triggeringContradictionRawId = readString(
+    record.triggeringContradictionId
+  );
   const triggeringWorktreeRawId = readString(record.triggeringWorktreeId);
   const slOperator = readString(record.slOperator);
   return {
     ...readString(record._id) ? { id: readString(record._id) } : {},
     confidence: clampNumber(readNumber(record.confidence) ?? 0, 0, 1),
-    trigger: readString(record.trigger) ?? "manual",
+    trigger: normalizeRequiredString(record.trigger, "trigger"),
     ...readString(record.rationale) ? { rationale: readString(record.rationale) } : {},
     ...readNumber(record.assessedAt) ?? readNumber(record.timestamp) ? {
       timestamp: readNumber(record.assessedAt) ?? readNumber(record.timestamp)
@@ -11293,6 +12319,24 @@ function normalizeHistoryEntry(value) {
         triggeringEvidenceRawId
       )
     } : {},
+    ...triggeringQuestionRawId ? {
+      triggeringQuestionId: encodeHistoryReferenceId(
+        "que",
+        triggeringQuestionRawId
+      )
+    } : {},
+    ...triggeringAnswerRawId ? {
+      triggeringAnswerId: encodeHistoryReferenceId(
+        "ans",
+        triggeringAnswerRawId
+      )
+    } : {},
+    ...triggeringContradictionRawId ? {
+      triggeringContradictionId: encodeHistoryReferenceId(
+        "con",
+        triggeringContradictionRawId
+      )
+    } : {},
     ...triggeringWorktreeRawId ? {
       triggeringWorktreeId: encodeHistoryReferenceId(
         "wt",
@@ -11441,19 +12485,6 @@ function normalizeRelationships(relationships) {
   }
   return [...deduped.values()];
 }
-function toOpinion(confidence, certainty) {
-  const boundedConfidence = clampNumber(confidence, 0, 1);
-  const boundedCertainty = certainty === void 0 ? boundedConfidence === 0.5 ? 0.75 : 1 : clampNumber(certainty, 0, 1);
-  const belief = boundedConfidence * boundedCertainty;
-  const disbelief = (1 - boundedConfidence) * boundedCertainty;
-  const uncertainty = clampNumber(1 - boundedCertainty, 0, 1);
-  return {
-    b: belief,
-    d: disbelief,
-    u: uncertainty,
-    a: 0.5
-  };
-}
 function validateOpinionComponent(value, field) {
   if (value < 0 || value > 1) {
     throwBeliefsError({
@@ -11474,53 +12505,108 @@ function normalizeOpinionTuple(input) {
   const providedTupleCount = tupleValues.filter(
     (value) => value !== void 0
   ).length;
-  if (providedTupleCount > 0) {
-    if (providedTupleCount !== tupleValues.length) {
-      throwBeliefsError({
-        message: "[beliefs] belief, disbelief, uncertainty, and baseRate must all be provided together.",
-        status: 400,
-        code: "INVALID_REQUEST",
-        invariantCode: "belief.confidence_append_only",
-        suggestion: "Provide the full subjective-logic tuple or fall back to scalar confidence + certainty."
-      });
-    }
-    validateOpinionComponent(belief, "belief");
-    validateOpinionComponent(disbelief, "disbelief");
-    validateOpinionComponent(uncertainty, "uncertainty");
-    validateOpinionComponent(baseRate, "baseRate");
-    return {
-      b: belief,
-      d: disbelief,
-      u: uncertainty,
-      a: baseRate
-    };
-  }
-  const confidence = readNumber(input.confidence);
-  if (confidence === void 0) {
-    throwBeliefsError({
-      message: "[beliefs] confidence is required when no subjective-logic tuple is provided.",
-      status: 400,
-      code: "INVALID_REQUEST",
-      invariantCode: "belief.confidence_append_only",
-      suggestion: "Provide either confidence in [0, 1] or the full belief/disbelief/uncertainty/baseRate tuple."
-    });
-  }
-  if (confidence < 0 || confidence > 1) {
+  if (providedTupleCount !== tupleValues.length) {
     throwBeliefsError({
-      message: "[beliefs] confidence must be within [0, 1].",
+      message: "[beliefs] belief, disbelief, uncertainty, and baseRate must all be provided together.",
       status: 400,
       code: "INVALID_REQUEST",
       invariantCode: "belief.confidence_append_only",
-      suggestion: "Clamp confidence into the inclusive [0, 1] interval."
+      suggestion: "Provide the full subjective-logic tuple; scalar confidence payloads are not accepted."
     });
   }
-  return toOpinion(confidence, readNumber(input.certainty));
+  validateOpinionComponent(belief, "belief");
+  validateOpinionComponent(disbelief, "disbelief");
+  validateOpinionComponent(uncertainty, "uncertainty");
+  validateOpinionComponent(baseRate, "baseRate");
+  return {
+    b: belief,
+    d: disbelief,
+    u: uncertainty,
+    a: baseRate
+  };
 }
 function projectOpinion(opinion) {
   return opinion.b + opinion.a * opinion.u;
 }
+function normalizeEvidenceReference(value) {
+  return readString(value) ? decodeExternalId(readString(value), "evi") : void 0;
+}
+function normalizeQuestionReference(value) {
+  return readString(value) ? decodeExternalId(readString(value), "que") : void 0;
+}
+function normalizeAnswerReference(value) {
+  return readString(value) ? decodeExternalId(readString(value), "ans") : void 0;
+}
+function normalizeContradictionReference(value) {
+  return readString(value) ? decodeExternalId(readString(value), "con") : void 0;
+}
+function normalizeWorktreeReference(value) {
+  return readString(value) ? decodeExternalId(readString(value), "wt") : void 0;
+}
+function requireModulationProvenance(trigger, input) {
+  const provenance = {
+    triggeringEvidenceId: normalizeEvidenceReference(input.triggeringEvidenceId),
+    triggeringQuestionId: normalizeQuestionReference(input.triggeringQuestionId),
+    triggeringAnswerId: normalizeAnswerReference(input.triggeringAnswerId),
+    triggeringContradictionId: normalizeContradictionReference(
+      input.triggeringContradictionId
+    ),
+    triggeringWorktreeId: normalizeWorktreeReference(
+      input.triggeringWorktreeId
+    )
+  };
+  const hasTruthBearingArtifact = Object.values(provenance).some(Boolean);
+  const fail = (message, suggestion) => throwBeliefsError({
+    message,
+    status: 400,
+    code: "INVALID_REQUEST",
+    invariantCode: "belief.confidence_append_only",
+    suggestion
+  });
+  switch (trigger) {
+    case "evidence_added":
+    case "evidence_removed":
+      if (!provenance.triggeringEvidenceId) {
+        fail(
+          "[beliefs] Evidence-triggered confidence modulation requires triggeringEvidenceId.",
+          "Create or link the evidence first, then pass its evidence ID."
+        );
+      }
+      break;
+    case "contradiction_detected":
+    case "contradiction_resolved":
+      if (!provenance.triggeringContradictionId) {
+        fail(
+          "[beliefs] Contradiction-triggered confidence modulation requires triggeringContradictionId.",
+          "Create or resolve the contradiction first, then pass its contradiction ID."
+        );
+      }
+      break;
+    case "worktree_outcome":
+    case "worktree_completed":
+      if (!provenance.triggeringWorktreeId) {
+        fail(
+          "[beliefs] Worktree-triggered confidence modulation requires triggeringWorktreeId.",
+          "Complete the worktree first, then pass its worktree ID."
+        );
+      }
+      break;
+    case "agent_assessment":
+    case "fusion":
+    case "discount":
+    case "deduction":
+      if (!hasTruthBearingArtifact) {
+        fail(
+          "[beliefs] Confidence modulation requires evidence, answered question, answer, contradiction, or worktree provenance.",
+          "Pass triggeringEvidenceId, triggeringQuestionId, triggeringAnswerId, triggeringContradictionId, or triggeringWorktreeId."
+        );
+      }
+      break;
+  }
+  return provenance;
+}
 async function createBelief(port, input) {
-  const baseRate = normalizeRequiredBaseRate(input.baseRate);
+  const baseRate = normalizeBaseRate(input.baseRate);
   const created = await port.createBelief({
     topicId: normalizeRequiredString(input.topicId, "topicId"),
     text: normalizeRequiredString(input.text, "text"),
@@ -11635,6 +12721,8 @@ async function updateBeliefConfidence(port, input, options) {
   );
   const opinion = normalizeOpinionTuple(input);
   const projectedConfidence = projectOpinion(opinion);
+  const trigger = normalizeConfidenceTrigger(input.trigger);
+  const provenance = requireModulationProvenance(trigger, input);
   const existing = await port.fetchBelief(rawId);
   const policy = allowAlwaysPolicy;
   const decision = await policy.canScore({
@@ -11653,13 +12741,13 @@ async function updateBeliefConfidence(port, input, options) {
       details: { beliefId: encodeId("bel", rawId) }
     });
   }
-  const trigger = normalizeConfidenceTrigger(input.trigger);
   const rationale = normalizeRequiredString(input.rationale, "rationale");
   const result = await port.modulateConfidence({
     beliefRawId: rawId,
     opinion,
     trigger,
-    rationale
+    rationale,
+    ...provenance
   });
   const requestId = createRequestId();
   const relationships = normalizeRelationships(await port.getRelationships(rawId));
@@ -12508,7 +13596,12 @@ function createGatewayBeliefPort(authContext) {
         belief: input.opinion.b,
         disbelief: input.opinion.d,
         uncertainty: input.opinion.u,
-        baseRate: input.opinion.a
+        baseRate: input.opinion.a,
+        triggeringEvidenceId: input.triggeringEvidenceId,
+        triggeringQuestionId: input.triggeringQuestionId,
+        triggeringAnswerId: input.triggeringAnswerId,
+        triggeringContradictionId: input.triggeringContradictionId,
+        triggeringWorktreeId: input.triggeringWorktreeId
       });
     },
     archiveBelief(input) {
@@ -13826,6 +14919,7 @@ async function createEvidence(deps, input) {
     ...input,
     topicId: normalizeRequiredString4(input.topicId, "topicId"),
     text: normalizeRequiredString4(input.text, "text"),
+    rationale: normalizeRequiredString4(input.rationale, "rationale"),
     weight: normalizeWeight(input.weight, 1),
     target
   });
@@ -13965,7 +15059,11 @@ function createGatewayEvidencePort(authContext) {
         contentType: input.contentType,
         kind: input.kind,
         sourceUrl: input.source,
-        metadata: input.metadata,
+        metadata: {
+          ...input.metadata ?? {},
+          rationale: input.rationale
+        },
+        rationale: input.rationale,
         userId: authContext.userId
       });
       const createdRecord = created && typeof created === "object" ? created : {};
@@ -17180,6 +18278,24 @@ function readString19(value) {
 function readNumber13(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+function normalizeGroupBy(value) {
+  if (value === "lane" || value === "flat") {
+    return value;
+  }
+  return "campaign";
+}
+function readCampaign(record) {
+  return readNumber13(record.campaign);
+}
+function readLane(record) {
+  return readString19(record.lane);
+}
+function readLaneOrderInCampaign(record) {
+  return readNumber13(record.laneOrderInCampaign);
+}
+function readOrderInLane(record) {
+  return readNumber13(record.orderInLane);
+}
 function readStringArray9(value) {
   if (!Array.isArray(value)) {
     return void 0;
@@ -17187,6 +18303,9 @@ function readStringArray9(value) {
   const normalized = value.map((entry) => readString19(entry)).filter((entry) => Boolean(entry));
   return normalized.length > 0 ? normalized : void 0;
 }
+function compareNullableNumber(left, right, fallback = 9999) {
+  return (left ?? fallback) - (right ?? fallback);
+}
 function requireString3(value, field) {
   const normalized = readString19(value);
   if (!normalized) {
@@ -17246,21 +18365,25 @@ function normalizeWorktreeRecord(value) {
   }
   const worktreeId = encodeWorktreeId(rawId);
   const topicRawId = readString19(record.topicId);
+  const campaign = readCampaign(record);
+  const lane = readLane(record);
+  const laneOrderInCampaign = readLaneOrderInCampaign(record);
+  const orderInLane = readOrderInLane(record);
   return {
     worktreeId,
     id: worktreeId,
     ...topicRawId ? { topicId: encodeTopicId3(topicRawId) } : {},
     title: readString19(record.title) ?? readString19(record.name) ?? "Untitled",
     ...readString19(record.status) ? { status: readString19(record.status) } : {},
+    ...campaign !== void 0 ? { campaign } : {},
     ...readString19(record.phase) ? { phase: readString19(record.phase) } : {},
     ...readString19(record.branchId) !== void 0 ? { branchId: readString19(record.branchId) ?? null } : {},
     ...readString19(record.objective) ? { objective: readString19(record.objective) } : {},
     ...readString19(record.hypothesis) ? { hypothesis: readString19(record.hypothesis) } : {},
     ...readString19(record.gate) ? { gate: readString19(record.gate) } : {},
-    ...readString19(record.track) ? { track: readString19(record.track) } : {},
-    ...readNumber13(record.trackPosition) !== void 0 ? { trackPosition: readNumber13(record.trackPosition) } : {},
-    ...readNumber13(record.executionBand) !== void 0 ? { executionBand: readNumber13(record.executionBand) } : {},
-    ...readNumber13(record.executionOrder) !== void 0 ? { executionOrder: readNumber13(record.executionOrder) } : {},
+    ...lane ? { lane } : {},
+    ...laneOrderInCampaign !== void 0 ? { laneOrderInCampaign } : {},
+    ...orderInLane !== void 0 ? { orderInLane } : {},
     ...readStringArray9(record.dependsOn) ? {
       dependsOn: readStringArray9(record.dependsOn).map(
         (id) => encodeWorktreeId(id)
@@ -17304,6 +18427,124 @@ function dedupeWorktrees(records) {
   }
   return [...byId.values()];
 }
+function sortWorktreeRecords(records) {
+  return [...records].sort((left, right) => {
+    const campaignDiff = compareNullableNumber(left.campaign, right.campaign);
+    if (campaignDiff !== 0) {
+      return campaignDiff;
+    }
+    const laneOrderDiff = compareNullableNumber(
+      left.laneOrderInCampaign,
+      right.laneOrderInCampaign
+    );
+    if (laneOrderDiff !== 0) {
+      return laneOrderDiff;
+    }
+    const laneDiff = (left.lane ?? "~").localeCompare(right.lane ?? "~");
+    if (laneDiff !== 0) {
+      return laneDiff;
+    }
+    const orderDiff = compareNullableNumber(
+      left.orderInLane,
+      right.orderInLane
+    );
+    if (orderDiff !== 0) {
+      return orderDiff;
+    }
+    return left.title.localeCompare(right.title);
+  });
+}
+function groupWorktreesByLane(records) {
+  const groups2 = /* @__PURE__ */ new Map();
+  for (const worktree of sortWorktreeRecords(records)) {
+    const lane = worktree.lane ?? null;
+    const key = lane ?? "__unlaned__";
+    const group = groups2.get(key) ?? {
+      lane,
+      laneOrderInCampaign: worktree.laneOrderInCampaign ?? null,
+      worktrees: []
+    };
+    group.laneOrderInCampaign = group.laneOrderInCampaign ?? worktree.laneOrderInCampaign ?? null;
+    group.worktrees.push(worktree);
+    groups2.set(key, group);
+  }
+  return [...groups2.values()].sort((left, right) => {
+    const orderDiff = compareNullableNumber(
+      left.laneOrderInCampaign,
+      right.laneOrderInCampaign
+    );
+    if (orderDiff !== 0) {
+      return orderDiff;
+    }
+    return (left.lane ?? "~").localeCompare(right.lane ?? "~");
+  });
+}
+function groupWorktreesByCampaign(records) {
+  const campaignGroups = /* @__PURE__ */ new Map();
+  for (const worktree of sortWorktreeRecords(records)) {
+    const campaign = worktree.campaign ?? null;
+    const rows = campaignGroups.get(campaign) ?? [];
+    rows.push(worktree);
+    campaignGroups.set(campaign, rows);
+  }
+  return [...campaignGroups.entries()].sort(([left], [right]) => compareNullableNumber(left, right)).map(([campaign, rows]) => ({
+    campaign,
+    lanes: groupWorktreesByLane(rows)
+  }));
+}
+function decorateWorktreeListResult(worktrees2, groupBy) {
+  const result = {
+    worktrees: sortWorktreeRecords(worktrees2),
+    total: worktrees2.length,
+    groupBy
+  };
+  if (groupBy === "campaign") {
+    result.campaigns = groupWorktreesByCampaign(worktrees2);
+  } else if (groupBy === "lane") {
+    result.lanes = groupWorktreesByLane(worktrees2);
+  }
+  return result;
+}
+function buildWorktreeCampaignList(records) {
+  const campaigns = groupWorktreesByCampaign(records).map((campaignGroup) => ({
+    campaign: campaignGroup.campaign,
+    lanes: campaignGroup.lanes.map((laneGroup) => {
+      const worktrees2 = laneGroup.worktrees;
+      const nextWorktree = worktrees2.find(
+        (worktree) => worktree.status !== "completed" && worktree.status !== "merged" && worktree.status !== "dismissed" && worktree.status !== "abandoned"
+      );
+      const blockedCount = worktrees2.filter(
+        (worktree) => (worktree.dependsOn ?? []).length > 0
+      ).length;
+      return {
+        lane: laneGroup.lane,
+        laneOrderInCampaign: laneGroup.laneOrderInCampaign,
+        worktreeCount: worktrees2.length,
+        activeCount: worktrees2.filter((worktree) => worktree.status === "active").length,
+        readyCount: worktrees2.filter(
+          (worktree) => (worktree.status === "planning" || worktree.status === "suggested") && (worktree.dependsOn ?? []).length === 0
+        ).length,
+        blockedCount,
+        completedCount: worktrees2.filter(
+          (worktree) => worktree.status === "completed" || worktree.status === "merged"
+        ).length,
+        ...nextWorktree ? {
+          nextWorktree: {
+            worktreeId: nextWorktree.worktreeId,
+            title: nextWorktree.title,
+            status: nextWorktree.status,
+            orderInLane: nextWorktree.orderInLane,
+            gate: nextWorktree.gate
+          }
+        } : {}
+      };
+    })
+  }));
+  return {
+    campaigns,
+    totalWorktrees: records.length
+  };
+}
 async function createWorktree(deps, input) {
   const topicRawId = decodeExternalId9(input.topicId, "top", "topicId");
   const created = await deps.createWorktree({
@@ -17316,7 +18557,10 @@ async function createWorktree(deps, input) {
     ),
     autoShape: typeof input.autoShape === "boolean" ? input.autoShape : void 0,
     domainPackId: readString19(input.domainPackId),
-    executionOrder: typeof input.executionOrder === "number" && Number.isFinite(input.executionOrder) ? input.executionOrder : void 0,
+    campaign: typeof input.campaign === "number" && Number.isFinite(input.campaign) ? input.campaign : void 0,
+    lane: readString19(input.lane),
+    laneOrderInCampaign: typeof input.laneOrderInCampaign === "number" && Number.isFinite(input.laneOrderInCampaign) ? input.laneOrderInCampaign : void 0,
+    orderInLane: typeof input.orderInLane === "number" && Number.isFinite(input.orderInLane) ? input.orderInLane : void 0,
     dependsOn: input.dependsOn?.map(
       (id) => decodeExternalId9(id, "wt", "dependsOn")
     ),
@@ -17341,15 +18585,43 @@ async function listWorktrees(deps, query) {
     limit: typeof query.limit === "number" && Number.isFinite(query.limit) ? query.limit : void 0
   });
   const statusFilter = readString19(query.status)?.toLowerCase();
+  const laneFilter = readString19(query.lane);
+  const campaignFilter = typeof query.campaign === "number" && Number.isFinite(query.campaign) ? query.campaign : void 0;
   const normalized = dedupeWorktrees(
     (Array.isArray(worktrees2) ? worktrees2 : []).map((worktree) => normalizeWorktreeRecord(worktree)).filter(
       (worktree) => statusFilter ? String(worktree.status ?? "").toLowerCase() === statusFilter : true
+    ).filter(
+      (worktree) => laneFilter ? worktree.lane === laneFilter : true
+    ).filter(
+      (worktree) => campaignFilter !== void 0 ? worktree.campaign === campaignFilter : true
     )
   );
-  return {
-    worktrees: normalized,
-    total: normalized.length
-  };
+  return decorateWorktreeListResult(normalized, normalizeGroupBy(query.groupBy));
+}
+async function listCampaigns(deps, query = {}) {
+  const listAll = deps.listAllWorktrees;
+  if (!listAll) {
+    const worktrees2 = query.topicId ? await deps.listWorktreesByTopic({
+      topicId: decodeExternalId9(query.topicId, "top", "topicId"),
+      limit: query.limit
+    }) : [];
+    return buildWorktreeCampaignList(
+      (Array.isArray(worktrees2) ? worktrees2 : []).map(
+        (worktree) => normalizeWorktreeRecord(worktree)
+      )
+    );
+  }
+  const rows = await listAll({
+    status: readString19(query.status),
+    limit: typeof query.limit === "number" && Number.isFinite(query.limit) ? query.limit : void 0
+  });
+  const topicFilter = query.topicId ? decodeExternalId9(query.topicId, "top", "topicId") : void 0;
+  const normalized = dedupeWorktrees(
+    (Array.isArray(rows) ? rows : []).map((worktree) => normalizeWorktreeRecord(worktree)).filter(
+      (worktree) => topicFilter ? worktree.topicId === encodeTopicId3(topicFilter) : true
+    )
+  );
+  return buildWorktreeCampaignList(normalized);
 }
 async function activateWorktree(deps, input) {
   const rawId = decodeExternalId9(input.id, "wt", "id");
@@ -17367,10 +18639,10 @@ async function updateWorktree(deps, input) {
     objective: readString19(input.objective),
     hypothesis: readString19(input.hypothesis),
     rationale: readString19(input.rationale),
-    track: readString19(input.track),
-    trackPosition: typeof input.trackPosition === "number" && Number.isFinite(input.trackPosition) ? input.trackPosition : void 0,
-    executionBand: typeof input.executionBand === "number" && Number.isFinite(input.executionBand) ? input.executionBand : void 0,
-    executionOrder: typeof input.executionOrder === "number" && Number.isFinite(input.executionOrder) ? input.executionOrder : void 0,
+    campaign: typeof input.campaign === "number" && Number.isFinite(input.campaign) ? input.campaign : void 0,
+    lane: readString19(input.lane),
+    laneOrderInCampaign: typeof input.laneOrderInCampaign === "number" && Number.isFinite(input.laneOrderInCampaign) ? input.laneOrderInCampaign : void 0,
+    orderInLane: typeof input.orderInLane === "number" && Number.isFinite(input.orderInLane) ? input.orderInLane : void 0,
     dependsOn: input.dependsOn?.map(
       (id) => decodeExternalId9(id, "wt", "dependsOn")
     ),
@@ -17421,6 +18693,7 @@ async function mergeWorktree(deps, input) {
   for (const outcome of input.outcomes) {
     try {
       await deps.scoreBeliefOutcome({
+        worktreeRawId: rawId,
         beliefRawId: decodeExternalId9(outcome.beliefId, "bel", "beliefId"),
         confidence: outcome.confidence,
         rationale: requireString3(outcome.rationale, "rationale")
@@ -17471,23 +18744,23 @@ function resolveExternalId5(value, prefix) {
 }
 function summarizeWorktreeCollection(rows) {
   const worktrees2 = Array.isArray(rows) ? rows : [];
-  const tracks = {};
-  const bands = {};
+  const lanes = {};
+  const campaigns = {};
   for (const row of worktrees2) {
     if (!row || typeof row !== "object" || Array.isArray(row)) {
       continue;
     }
     const record = row;
-    const track = typeof record.track === "string" && record.track.trim().length > 0 ? record.track.trim() : "untracked";
-    tracks[track] = (tracks[track] ?? 0) + 1;
-    const bandValue = typeof record.executionBand === "number" ? String(record.executionBand) : "unbanded";
-    bands[bandValue] = (bands[bandValue] ?? 0) + 1;
+    const lane = typeof record.lane === "string" && record.lane.trim().length > 0 ? record.lane.trim() : "unlaned";
+    lanes[lane] = (lanes[lane] ?? 0) + 1;
+    const campaignValue = typeof record.campaign === "number" ? String(record.campaign) : "uncampaigned";
+    campaigns[campaignValue] = (campaigns[campaignValue] ?? 0) + 1;
   }
   return {
     worktrees: worktrees2,
     total: worktrees2.length,
-    tracks,
-    bands
+    lanes,
+    campaigns
   };
 }
 function buildCreateMutationArgs(input, userId) {
@@ -17502,7 +18775,10 @@ function buildCreateMutationArgs(input, userId) {
     ...objective ? { objective } : {},
     ...hypothesis ? { hypothesis } : {},
     ...objective || hypothesis ? { beliefFocus: hypothesis ?? objective } : {},
-    ...typeof input.executionOrder === "number" ? { executionOrder: input.executionOrder } : {},
+    ...typeof input.campaign === "number" ? { campaign: input.campaign } : {},
+    ...input.lane ? { lane: input.lane } : {},
+    ...typeof input.laneOrderInCampaign === "number" ? { laneOrderInCampaign: input.laneOrderInCampaign } : {},
+    ...typeof input.orderInLane === "number" ? { orderInLane: input.orderInLane } : {},
     ...Array.isArray(input.dependsOn) && input.dependsOn.length > 0 ? { dependsOn: input.dependsOn.map((id) => id) } : {},
     ...Array.isArray(input.blocks) && input.blocks.length > 0 ? { blocks: input.blocks.map((id) => id) } : {},
     ...gate ? { gate } : {},
@@ -17564,6 +18840,14 @@ function createGatewayWorktreesPort(authContext) {
         limit: args.limit
       });
     },
+    listAllWorktrees(args = {}) {
+      return authContext.convex.query(api.worktrees.listAll, {
+        ...args.status ? { status: args.status } : {},
+        ...args.lane ? { lane: args.lane } : {},
+        ...typeof args.campaign === "number" ? { campaign: args.campaign } : {},
+        ...typeof args.limit === "number" ? { limit: args.limit } : {}
+      });
+    },
     async createWorktree(input) {
       const shouldAutoShape = input.autoShape === true || Boolean(input.domainPackId?.trim());
       const created = shouldAutoShape ? await authContext.convex.mutation(api.worktrees.createShaped, {
@@ -17628,6 +18912,7 @@ function createGatewayWorktreesPort(authContext) {
         trigger: "worktree_outcome",
         rationale: args.rationale,
         userId: authContext.userId,
+        triggeringWorktreeId: args.worktreeRawId,
         ...opinion
       });
     },
@@ -17637,10 +18922,10 @@ function createGatewayWorktreesPort(authContext) {
         ...input.objective ? { objective: input.objective } : {},
         ...input.hypothesis ? { hypothesis: input.hypothesis } : {},
         ...input.rationale ? { rationale: input.rationale } : {},
-        ...input.track ? { track: input.track } : {},
-        ...typeof input.trackPosition === "number" ? { trackPosition: input.trackPosition } : {},
-        ...typeof input.executionBand === "number" ? { executionBand: input.executionBand } : {},
-        ...typeof input.executionOrder === "number" ? { executionOrder: input.executionOrder } : {},
+        ...typeof input.campaign === "number" ? { campaign: input.campaign } : {},
+        ...input.lane ? { lane: input.lane } : {},
+        ...typeof input.laneOrderInCampaign === "number" ? { laneOrderInCampaign: input.laneOrderInCampaign } : {},
+        ...typeof input.orderInLane === "number" ? { orderInLane: input.orderInLane } : {},
         ...input.dependsOn ? { dependsOn: input.dependsOn.map((id) => id) } : {},
         ...input.blocks ? { blocks: input.blocks.map((id) => id) } : {},
         ...input.gate ? { gate: input.gate } : {},
@@ -17681,7 +18966,10 @@ async function createWorktreeFromGatewayAuth(authContext, input) {
       objective: payload.objective,
       hypothesis: payload.hypothesis,
       gate: payload.gate,
-      executionOrder: payload.executionOrder,
+      campaign: payload.campaign,
+      lane: payload.lane,
+      laneOrderInCampaign: payload.laneOrderInCampaign,
+      orderInLane: payload.orderInLane,
       dependsOn: payload.dependsOn ?? [],
       blocks: payload.blocks ?? [],
       targetBeliefIds: payload.targetBeliefIds ?? [],
@@ -17699,12 +18987,15 @@ function listWorktreesFromGatewayAuth(authContext, query) {
 async function listAllWorktreesFromGatewayAuth(authContext, query = {}) {
   const rows = await authContext.convex.query(api.worktrees.listAll, {
     ...query.status ? { status: query.status } : {},
-    ...query.track ? { track: query.track } : {},
-    ...typeof query.executionBand === "number" ? { executionBand: query.executionBand } : {},
+    ...query.lane ? { lane: query.lane } : {},
+    ...typeof query.campaign === "number" ? { campaign: query.campaign } : {},
     ...typeof query.limit === "number" ? { limit: query.limit } : {}
   });
   return summarizeWorktreeCollection(rows);
 }
+async function listCampaignsFromGatewayAuth(authContext, query = {}) {
+  return listCampaigns(createGatewayWorktreesPort(authContext), query);
+}
 async function activateWorktreeFromGatewayAuth(authContext, input) {
   const payload = await activateWorktree(createGatewayWorktreesPort(authContext), input);
   await emitWorktreeEventFromGatewayAuth(authContext, {
@@ -17727,10 +19018,10 @@ async function updateWorktreeFromGatewayAuth(authContext, input) {
     resourceId: payload.worktreeId,
     data: {
       hypothesis: payload.hypothesis,
-      track: payload.track,
-      trackPosition: payload.trackPosition,
-      executionBand: payload.executionBand,
-      executionOrder: payload.executionOrder,
+      campaign: payload.campaign,
+      lane: payload.lane,
+      laneOrderInCampaign: payload.laneOrderInCampaign,
+      orderInLane: payload.orderInLane,
       dependsOn: payload.dependsOn ?? [],
       blocks: payload.blocks ?? [],
       gate: payload.gate
@@ -17970,10 +19261,17 @@ async function handleBeliefUpdateConfidence(args) {
       args.authContext,
       {
         id: args.beliefId,
-        confidence: readNumber14(body.confidence) ?? Number.NaN,
+        belief: readNumber14(body.belief) ?? Number.NaN,
+        disbelief: readNumber14(body.disbelief) ?? Number.NaN,
+        uncertainty: readNumber14(body.uncertainty) ?? Number.NaN,
+        baseRate: readNumber14(body.baseRate) ?? Number.NaN,
         trigger: readString21(body.trigger),
         rationale: readString21(body.rationale) ?? "",
-        certainty: readNumber14(body.certainty),
+        triggeringEvidenceId: readString21(body.triggeringEvidenceId),
+        triggeringQuestionId: readString21(body.triggeringQuestionId),
+        triggeringAnswerId: readString21(body.triggeringAnswerId),
+        triggeringContradictionId: readString21(body.triggeringContradictionId),
+        triggeringWorktreeId: readString21(body.triggeringWorktreeId) ?? readString21(body.worktreeId),
         maxInlinePropagationTargets: readNumber14(body.maxInlinePropagationTargets)
       }
     );
@@ -18769,6 +20067,7 @@ async function handleEvidenceCreate(args) {
       targetId: readString24(body.targetId),
       targetType: readString24(body.targetType),
       weight: readNumber16(body.weight),
+      rationale: readString24(body.rationale) ?? "",
       metadata: asRecord19(body.metadata),
       title: readString24(body.title),
       content: readString24(body.content),
@@ -20663,7 +21962,10 @@ async function handleWorktreeCreate(args) {
       beliefIds: readStringArray17(body.beliefIds) ?? readStringArray17(body.beliefs),
       autoShape: typeof body.autoShape === "boolean" ? body.autoShape : void 0,
       domainPackId: readString33(body.domainPackId),
-      executionOrder: readNumber22(body.executionOrder),
+      campaign: readNumber22(body.campaign),
+      lane: readString33(body.lane),
+      laneOrderInCampaign: readNumber22(body.laneOrderInCampaign),
+      orderInLane: readNumber22(body.orderInLane),
       dependsOn: readStringArray17(body.dependsOn),
       blocks: readStringArray17(body.blocks),
       gate: readString33(body.gate),
@@ -20692,6 +21994,9 @@ async function handleWorktreeList(args) {
     const payload = await listWorktreesFromGatewayAuth(args.authContext, {
       topicId: readString33(args.query.topicId) ?? "",
       status: readString33(args.query.status),
+      groupBy: readString33(args.query.groupBy),
+      lane: readString33(args.query.lane),
+      campaign: readNumber22(args.query.campaign),
       limit: readNumber22(args.query.limit)
     });
     return successResponse(payload, {
@@ -20711,8 +22016,9 @@ async function handleWorktreeListAll(args) {
   try {
     const payload = await listAllWorktreesFromGatewayAuth(args.authContext, {
       status: readString33(args.query.status),
-      track: readString33(args.query.track),
-      executionBand: readNumber22(args.query.executionBand),
+      lane: readString33(args.query.lane),
+      campaign: readNumber22(args.query.campaign),
+      groupBy: readString33(args.query.groupBy),
       limit: readNumber22(args.query.limit)
     });
     return successResponse(payload, {
@@ -20728,6 +22034,26 @@ async function handleWorktreeListAll(args) {
     );
   }
 }
+async function handleWorktreeListCampaigns(args) {
+  try {
+    const payload = await listCampaignsFromGatewayAuth(args.authContext, {
+      topicId: readString33(args.query.topicId),
+      status: readString33(args.query.status),
+      limit: readNumber22(args.query.limit)
+    });
+    return successResponse(payload, {
+      correlationId: args.correlationId,
+      policyTraceId: args.policyTraceId
+    });
+  } catch (error) {
+    return handleWorktreesError(
+      error,
+      "Failed to list pipeline campaigns.",
+      args.correlationId,
+      args.policyTraceId
+    );
+  }
+}
 async function handleWorktreeActivate(args) {
   try {
     const payload = await activateWorktreeFromGatewayAuth(args.authContext, {
@@ -20754,10 +22080,10 @@ async function handleWorktreeUpdate(args) {
       objective: readString33(body.objective),
       hypothesis: readString33(body.hypothesis),
       rationale: readString33(body.rationale),
-      track: readString33(body.track),
-      trackPosition: readNumber22(body.trackPosition),
-      executionBand: readNumber22(body.executionBand),
-      executionOrder: readNumber22(body.executionOrder),
+      campaign: readNumber22(body.campaign),
+      lane: readString33(body.lane),
+      laneOrderInCampaign: readNumber22(body.laneOrderInCampaign),
+      orderInLane: readNumber22(body.orderInLane),
       dependsOn: readStringArray17(body.dependsOn),
       blocks: readStringArray17(body.blocks),
       gate: readString33(body.gate),
@@ -20944,6 +22270,6 @@ async function handleWorktreeBulkCreate(args) {
   }
 }
 
-export { handleBeliefArchive, handleBeliefBatchUpdateCriticality, handleBeliefBisect, handleBeliefConfidenceHistory, handleBeliefCreate, handleBeliefCreateContract, handleBeliefFork, handleBeliefGet, handleBeliefLineage, handleBeliefLink, handleBeliefList, handleBeliefReassignTopic, handleBeliefRefine, handleBeliefRelationships, handleBeliefUnlinkEvidence, handleBeliefUpdateConfidence, handleBeliefUpdateCriticality, handleBeliefUpdateRationale, handleBeliefUpdateStatus, handleContradictionFlag, handleContradictionGet, handleContradictionList, handleEdgeBatchCreate, handleEdgeCreate, handleEdgeDelete, handleEdgeList, handleEdgeRemove, handleEdgeTraverse, handleEdgeUpdate, handleEdgesRemoveBetween, handleEventsList, handleEventsReplay, handleEvidenceClassify, handleEvidenceClassifyBatch, handleEvidenceCreate, handleEvidenceFlagIncorrect, handleEvidenceGet, handleEvidenceLink, handleEvidenceList, handleEvidenceRemove, handleEvidenceSearch, handleEvidenceUpdate, handleEvidenceUpdateStatus, handleEvidenceUpdateVerificationStatus, handleGraphAnalyze, handleGraphBias, handleGraphFalsify, handleGraphGaps, handleGraphNeighborhood, handleGraphTraverse, handleIdentityWhoami, handleOntologyBind, handleOntologyGet, handleOntologyList, handleOntologyMatch, handleQuestionAdd, handleQuestionAdvanceToConviction, handleQuestionAnswer, handleQuestionArchive, handleQuestionBatchCreate, handleQuestionCreate, handleQuestionDelete, handleQuestionFinalizeConviction, handleQuestionGet, handleQuestionGetAnswer, handleQuestionList, handleQuestionRefine, handleQuestionUpdate, handleQuestionUpdateConviction, handleQuestionUpdatePriority, handleQuestionUpdateStatus, handleSearchResources, handleSourceGet, handleSourceUpsert, handleTaskComplete, handleTaskCreate, handleTaskList, handleTaskUpdate, handleTopicBulkCreate, handleTopicCoverage, handleTopicCreate, handleTopicGet, handleTopicList, handleTopicRemove, handleTopicTree, handleTopicUpdate, handleWebhookCreate, handleWebhookDelete, handleWebhookDeliveries, handleWebhookGet, handleWebhookHealth, handleWebhookList, handleWebhookTest, handleWebhookUpdate, handleWorktreeActivate, handleWorktreeAdvancePhase, handleWorktreeBulkCreate, handleWorktreeComplete, handleWorktreeCreate, handleWorktreeList, handleWorktreeListAll, handleWorktreeMerge, handleWorktreePatchState, handleWorktreeSetPhase, handleWorktreeUpdate, handleWorktreeUpdateTargets };
+export { handleBeliefArchive, handleBeliefBatchUpdateCriticality, handleBeliefBisect, handleBeliefConfidenceHistory, handleBeliefCreate, handleBeliefCreateContract, handleBeliefFork, handleBeliefGet, handleBeliefLineage, handleBeliefLink, handleBeliefList, handleBeliefReassignTopic, handleBeliefRefine, handleBeliefRelationships, handleBeliefUnlinkEvidence, handleBeliefUpdateConfidence, handleBeliefUpdateCriticality, handleBeliefUpdateRationale, handleBeliefUpdateStatus, handleContradictionFlag, handleContradictionGet, handleContradictionList, handleEdgeBatchCreate, handleEdgeCreate, handleEdgeDelete, handleEdgeList, handleEdgeRemove, handleEdgeTraverse, handleEdgeUpdate, handleEdgesRemoveBetween, handleEventsList, handleEventsReplay, handleEvidenceClassify, handleEvidenceClassifyBatch, handleEvidenceCreate, handleEvidenceFlagIncorrect, handleEvidenceGet, handleEvidenceLink, handleEvidenceList, handleEvidenceRemove, handleEvidenceSearch, handleEvidenceUpdate, handleEvidenceUpdateStatus, handleEvidenceUpdateVerificationStatus, handleGraphAnalyze, handleGraphBias, handleGraphFalsify, handleGraphGaps, handleGraphNeighborhood, handleGraphTraverse, handleIdentityWhoami, handleOntologyBind, handleOntologyGet, handleOntologyList, handleOntologyMatch, handleQuestionAdd, handleQuestionAdvanceToConviction, handleQuestionAnswer, handleQuestionArchive, handleQuestionBatchCreate, handleQuestionCreate, handleQuestionDelete, handleQuestionFinalizeConviction, handleQuestionGet, handleQuestionGetAnswer, handleQuestionList, handleQuestionRefine, handleQuestionUpdate, handleQuestionUpdateConviction, handleQuestionUpdatePriority, handleQuestionUpdateStatus, handleSearchResources, handleSourceGet, handleSourceUpsert, handleTaskComplete, handleTaskCreate, handleTaskList, handleTaskUpdate, handleTopicBulkCreate, handleTopicCoverage, handleTopicCreate, handleTopicGet, handleTopicList, handleTopicRemove, handleTopicTree, handleTopicUpdate, handleWebhookCreate, handleWebhookDelete, handleWebhookDeliveries, handleWebhookGet, handleWebhookHealth, handleWebhookList, handleWebhookTest, handleWebhookUpdate, handleWorktreeActivate, handleWorktreeAdvancePhase, handleWorktreeBulkCreate, handleWorktreeComplete, handleWorktreeCreate, handleWorktreeList, handleWorktreeListAll, handleWorktreeListCampaigns, handleWorktreeMerge, handleWorktreePatchState, handleWorktreeSetPhase, handleWorktreeUpdate, handleWorktreeUpdateTargets };
 //# sourceMappingURL=gateway.js.map
 //# sourceMappingURL=gateway.js.map