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

package/dist/hosted-route.js

@@ -3,6 +3,8 @@ import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mc
 import '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import { v } from 'convex/values';
+import * as fs from 'fs';
+import * as path from 'path';
 
 // src/hosted-route.ts
 
@@ -234,14 +236,15 @@ function normalizeCanonicalLucernAuthContext(input) {
   );
   const roles = cleanStringList(input.roles);
   const scopes = cleanStringList(input.scopes);
-  if (roles.length === 0 || scopes.length === 0) {
+  const principalType = requirePrincipalType(input.principalType);
+  const authMode = requireAuthMode(input.authMode);
+  const roleBasedInteractiveAuth = authMode === "interactive_user" && roles.length > 0;
+  if (roles.length === 0 || scopes.length === 0 && !roleBasedInteractiveAuth) {
     throw new LucernSdkAuthContextError(
       "membership_missing",
       "Canonical Lucern SDK auth context requires non-empty roles and scopes."
     );
   }
-  const principalType = requirePrincipalType(input.principalType);
-  const authMode = requireAuthMode(input.authMode);
   const subject = cleanString(input.permit?.subject) ?? principalId;
   const tenant = cleanString(input.permit?.tenant) ?? tenantId;
   const workspace = cleanString(input.permit?.workspace) ?? workspaceId;
@@ -1410,8 +1413,8 @@ function maybeThrowDeviceError(payload) {
 function createAuthDeviceClient(config = {}) {
   const fetchImpl = config.fetchImpl ?? fetch;
   const baseUrl = authBaseUrl(config);
-  async function post(path, body4) {
-    return fetchImpl(`${baseUrl}${path}`, {
+  async function post(path2, body4) {
+    return fetchImpl(`${baseUrl}${path2}`, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(body4)
@@ -4348,7 +4351,9 @@ function createGraphAnalysisClient(config = {}) {
           topicId: requireTopicId2(input),
           workspaceId: input.workspaceId,
           analysisId: input.analysisId,
-          since: input.since,
+          minimumCreatedAt: input.minimumCreatedAt ?? input.since ?? input.createdAt ?? input.analysisCreatedAt,
+          sourceNodeIds: input.sourceNodeIds?.join(",") ?? (input.nodeId ? input.nodeId : void 0),
+          sourceEdgeIds: input.sourceEdgeIds?.join(",") ?? (input.edgeId ? input.edgeId : void 0),
           limit: input.limit,
           cursor: input.cursor
         })}`
@@ -5113,6 +5118,7 @@ var CONTRACTS = {
   "archive_belief": { method: "DELETE", path: "/beliefs", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
   "archive_ontology": { method: "DELETE", path: "/ontologies", kind: "mutation", idempotent: true, surfaceIntent: "mcp_governance" },
   "archive_question": { method: "DELETE", path: "/questions", kind: "mutation", idempotent: true, surfaceIntent: "mcp_core" },
+  "begin_build_session": { method: "POST", path: "/mcp/build-session/begin", kind: "mutation", idempotent: true, surfaceIntent: "system" },
   "bisect_confidence": { method: "POST", path: "/beliefs/confidence/bisect", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
   "broadcast_message": { method: "POST", path: "/coordination/messages/broadcast", kind: "mutation", idempotent: true, surfaceIntent: "system" },
   "check_permission": { method: "POST", path: "/identity/check-permission", kind: "query", idempotent: false, surfaceIntent: "mcp_core" },
@@ -5241,9 +5247,9 @@ function createFunctionSurfaceClient(config = {}) {
   function execute(name, input, idempotencyKey) {
     const contract = CONTRACTS[name];
     const payload = withSdkSessionId(input, sessionId);
-    const path = contract.method === "GET" ? `${contract.path}${toFunctionSurfaceQuery(payload)}` : contract.path;
+    const path2 = contract.method === "GET" ? `${contract.path}${toFunctionSurfaceQuery(payload)}` : contract.path;
     return gateway.request({
-      path: `/api/platform/v1${path}`,
+      path: `/api/platform/v1${path2}`,
       method: contract.method,
       body: contract.method === "GET" ? void 0 : payload,
       idempotencyKey: contract.kind !== "query" && Boolean(contract.idempotent) ? idempotencyKey ?? randomIdempotencyKey() : void 0
@@ -5284,6 +5290,9 @@ function createFunctionSurfaceClient(config = {}) {
     archiveQuestion(input = {}, idempotencyKey) {
       return execute("archive_question", input, idempotencyKey);
     },
+    beginBuildSession(input = {}, idempotencyKey) {
+      return execute("begin_build_session", input, idempotencyKey);
+    },
     bisectConfidence(input = {}, idempotencyKey) {
       return execute("bisect_confidence", input, idempotencyKey);
     },
@@ -7218,6 +7227,13 @@ function requireTopicId4(args) {
   }
   return topicId;
 }
+function requireTopicOrProjectId(args) {
+  const topicId = args.topicId?.trim() || args.projectId?.trim() || void 0;
+  if (!topicId) {
+    throw new Error("topicId is required");
+  }
+  return topicId;
+}
 var AUDIT_NODE_REFERENCE_KEY_PATTERN = /(^|_)(id|nodeid|beliefid|resourceid|targetid|sourceid|subjectid|globalid|entityid|recordid|fromnodeid|tonodeid|linkednodeid|linkedbeliefid|nodeids|beliefids|resourceids)$/i;
 function matchesAuditNodeReference(value, nodeId) {
   if (Array.isArray(value)) {
@@ -7253,6 +7269,23 @@ function requireBaseRate(args) {
 function exposeGatewayData(response) {
   return Object.assign({}, response, response.data);
 }
+function sdkQueryString(input) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        params.set(key, value.join(","));
+      }
+      continue;
+    }
+    params.set(key, String(value));
+  }
+  const serialized = params.toString();
+  return serialized ? `?${serialized}` : "";
+}
 function createLucernClient(config = {}) {
   const gatewayConfig = toGatewayConfig(config);
   const beliefsClient = createBeliefsClient(gatewayConfig);
@@ -7673,6 +7706,30 @@ function createLucernClient(config = {}) {
     batchCreate(input, idempotencyKey) {
       return graphClient.batchCreateNodes(input, idempotencyKey);
     },
+    listByTopicAndType(input) {
+      return gateway.request({
+        path: `/api/platform/v1/nodes${sdkQueryString({
+          topicId: requireTopicOrProjectId(input),
+          nodeType: input.nodeType,
+          nodeTypes: input.nodeTypes,
+          query: input.query,
+          sourceText: input.sourceText,
+          limit: input.limit,
+          cursor: input.cursor
+        })}`
+      }).then(exposeGatewayData);
+    },
+    countByTopicAndType(input) {
+      return gateway.request({
+        path: `/api/platform/v1/nodes/count${sdkQueryString({
+          topicId: requireTopicOrProjectId(input),
+          nodeType: input.nodeType,
+          nodeTypes: input.nodeTypes,
+          query: input.query,
+          limit: input.limit
+        })}`
+      }).then(exposeGatewayData);
+    },
     supersede(input, idempotencyKey) {
       return graphClient.supersedeNode(input, idempotencyKey);
     },
@@ -7683,6 +7740,78 @@ function createLucernClient(config = {}) {
       return graphClient.hardDeleteNode(input, idempotencyKey);
     }
   };
+  const publicationNamespace = {
+    create(input, idempotencyKey) {
+      return gateway.request({
+        path: "/api/platform/v1/publication",
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      }).then(exposeGatewayData);
+    },
+    update(publicationId, input, idempotencyKey) {
+      return gateway.request({
+        path: `/api/platform/v1/publication/${encodeURIComponent(
+          publicationId
+        )}`,
+        method: "PATCH",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      }).then(exposeGatewayData);
+    },
+    list(input = {}) {
+      return gateway.request({
+        path: `/api/platform/v1/publication${sdkQueryString(input)}`
+      }).then(exposeGatewayData);
+    },
+    getByTopic(input) {
+      const topicId = typeof input === "string" ? input : input.topicId;
+      const workspaceId = typeof input === "string" ? void 0 : input.workspaceId;
+      return gateway.request({
+        path: `/api/platform/v1/publication/by-topic/${encodeURIComponent(
+          topicId
+        )}${sdkQueryString({ workspaceId })}`
+      }).then(exposeGatewayData);
+    },
+    publish(publicationId, input = {}, idempotencyKey) {
+      return gateway.request({
+        path: `/api/platform/v1/publication/${encodeURIComponent(
+          publicationId
+        )}/publish`,
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      }).then(exposeGatewayData);
+    },
+    unpublish(publicationId, input = {}, idempotencyKey) {
+      return gateway.request({
+        path: `/api/platform/v1/publication/${encodeURIComponent(
+          publicationId
+        )}/unpublish`,
+        method: "POST",
+        body: input,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+      }).then(exposeGatewayData);
+    },
+    remove(publicationId, input = {}) {
+      return gateway.request({
+        path: `/api/platform/v1/publication/${encodeURIComponent(
+          publicationId
+        )}${sdkQueryString(input)}`,
+        method: "DELETE"
+      }).then(exposeGatewayData);
+    }
+  };
+  const ontologyLinksNamespace = {
+    ...ontologyLinksClient,
+    resolveThemeSource(input) {
+      return gateway.request({
+        path: "/api/platform/v1/ontology-links/theme-source",
+        method: "POST",
+        body: input
+      }).then(exposeGatewayData);
+    }
+  };
   return {
     config,
     version: LUCERN_SDK_VERSION,
@@ -8164,6 +8293,54 @@ function createLucernClient(config = {}) {
         }));
       }
     },
+    themes: {
+      listByTopic(input) {
+        return gateway.request({
+          path: `/api/platform/v1/themes${sdkQueryString({
+            topicId: requireTopicOrProjectId(input),
+            query: input.query,
+            limit: input.limit,
+            cursor: input.cursor
+          })}`
+        }).then(exposeGatewayData);
+      }
+    },
+    graphSearch: {
+      keywordSearchNodes(input) {
+        return gateway.request({
+          path: "/api/platform/v1/graph-search/keyword-nodes",
+          method: "POST",
+          body: {
+            ...input,
+            topicId: requireTopicOrProjectId(input),
+            projectId: void 0
+          }
+        }).then(exposeGatewayData);
+      }
+    },
+    classifiers: {
+      listBeliefCandidates(input) {
+        return gateway.request({
+          path: `/api/platform/v1/classifiers/belief-candidates${sdkQueryString({
+            topicId: requireTopicOrProjectId(input),
+            classifierKey: input.classifierKey,
+            query: input.query,
+            limit: input.limit,
+            cursor: input.cursor
+          })}`
+        }).then(exposeGatewayData);
+      }
+    },
+    archetypes: {
+      getJudgmentSignature(input) {
+        return gateway.request({
+          path: `/api/platform/v1/archetypes/judgment-signature${sdkQueryString({
+            topicId: requireTopicOrProjectId(input),
+            principalId: input.principalId
+          })}`
+        }).then(exposeGatewayData);
+      }
+    },
     judgments: {
       create(input) {
         return decisionsClient.createJudgment(input);
@@ -8205,6 +8382,52 @@ function createLucernClient(config = {}) {
         });
       }
     },
+    decisions: {
+      create(input) {
+        return decisionsClient.createJudgment(input);
+      },
+      record(input) {
+        return decisionsClient.recordJudgment(input);
+      },
+      list(query5) {
+        return decisionsClient.listJudgments(query5);
+      },
+      get(decisionId) {
+        return decisionsClient.getJudgment(decisionId);
+      },
+      recordOutcome(decisionId, input) {
+        return decisionsClient.recordJudgmentOutcome(decisionId, input);
+      },
+      lessons(decisionId, input, idempotencyKey) {
+        return gateway.request({
+          path: `/api/platform/v1/decisions/${encodeURIComponent(
+            decisionId
+          )}/lessons`,
+          method: "POST",
+          body: input,
+          idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+        }).then(exposeGatewayData);
+      },
+      archive(decisionId, input = {}, idempotencyKey) {
+        return gateway.request({
+          path: `/api/platform/v1/decisions/${encodeURIComponent(
+            decisionId
+          )}/archive`,
+          method: "POST",
+          body: input,
+          idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+        }).then(exposeGatewayData);
+      },
+      readiness(topicId) {
+        return decisionsClient.getJudgmentReadiness({ topicId });
+      },
+      calibration(topicId) {
+        return decisionsClient.getJudgmentCalibration({ topicId });
+      },
+      pendingOutcomeReview(topicId) {
+        return decisionsClient.listPendingJudgmentOutcomeReview({ topicId });
+      }
+    },
     worktrees: {
       createBranch(input) {
         return workflowClient.createBranch(input);
@@ -8227,7 +8450,21 @@ function createLucernClient(config = {}) {
           topicId: requireTopicId4(input),
           objective: input.objective,
           hypothesis: input.hypothesis,
+          rationale: input.rationale,
+          worktreeType: input.worktreeType,
+          startDate: input.startDate,
+          endDate: input.endDate,
+          durationWeeks: input.durationWeeks,
+          confidenceImpact: input.confidenceImpact,
+          beliefFocus: input.beliefFocus,
           beliefIds: input.beliefIds,
+          targetBeliefIds: input.targetBeliefIds,
+          targetQuestionIds: input.targetQuestionIds,
+          keyQuestions: input.keyQuestions,
+          evidenceSignals: input.evidenceSignals,
+          decisionGate: input.decisionGate,
+          goCriteria: input.goCriteria,
+          noGoSignals: input.noGoSignals,
           autoShape: input.autoShape,
           domainPackId: input.domainPackId,
           campaign: input.campaign,
@@ -8240,7 +8477,8 @@ function createLucernClient(config = {}) {
           proofArtifacts: input.proofArtifacts,
           staffingHint: typeof input.staffingHint === "string" ? input.staffingHint : void 0,
           lastReconciledAt: input.lastReconciledAt,
-          autoFixPolicy: input.autoFixPolicy
+          autoFixPolicy: input.autoFixPolicy,
+          lensId: input.lensId
         });
       },
       add(input) {
@@ -8249,7 +8487,21 @@ function createLucernClient(config = {}) {
           topicId: requireTopicId4(input),
           objective: input.objective,
           hypothesis: input.hypothesis,
+          rationale: input.rationale,
+          worktreeType: input.worktreeType,
+          startDate: input.startDate,
+          endDate: input.endDate,
+          durationWeeks: input.durationWeeks,
+          confidenceImpact: input.confidenceImpact,
+          beliefFocus: input.beliefFocus,
           beliefIds: input.beliefIds,
+          targetBeliefIds: input.targetBeliefIds,
+          targetQuestionIds: input.targetQuestionIds,
+          keyQuestions: input.keyQuestions,
+          evidenceSignals: input.evidenceSignals,
+          decisionGate: input.decisionGate,
+          goCriteria: input.goCriteria,
+          noGoSignals: input.noGoSignals,
           autoShape: input.autoShape,
           domainPackId: input.domainPackId,
           campaign: input.campaign,
@@ -8262,7 +8514,8 @@ function createLucernClient(config = {}) {
           proofArtifacts: input.proofArtifacts,
           staffingHint: typeof input.staffingHint === "string" ? input.staffingHint : void 0,
           lastReconciledAt: input.lastReconciledAt,
-          autoFixPolicy: input.autoFixPolicy
+          autoFixPolicy: input.autoFixPolicy,
+          lensId: input.lensId
         });
       },
       list(query5) {
@@ -8272,6 +8525,22 @@ function createLucernClient(config = {}) {
           limit: query5.limit
         });
       },
+      listByTopic(query5) {
+        return worktreesFacade.list({
+          topicId: requireTopicId4(query5),
+          status: query5.status,
+          limit: query5.limit
+        });
+      },
+      findByPairedSprint(input) {
+        return gateway.request({
+          path: `/api/platform/v1/worktrees/paired-sprint${sdkQueryString({
+            sprintId: input.sprintId,
+            topicId: input.topicId ?? input.projectId,
+            limit: input.limit
+          })}`
+        }).then(exposeGatewayData);
+      },
       activate(worktreeId) {
         return worktreesFacade.activate({ id: worktreeId });
       },
@@ -8423,6 +8692,31 @@ function createLucernClient(config = {}) {
           status: typeof input.status === "string" ? input.status : void 0,
           limit: typeof input.limit === "number" ? input.limit : void 0
         });
+      },
+      listByTopic(input) {
+        return tasksFacade.list({
+          topicId: requireTopicId4(input),
+          status: typeof input.status === "string" ? input.status : void 0,
+          limit: typeof input.limit === "number" ? input.limit : void 0
+        });
+      },
+      listByWorktree(input) {
+        return tasksFacade.list({
+          topicId: typeof input.topicId === "string" ? input.topicId : void 0,
+          worktreeId: input.worktreeId,
+          status: typeof input.status === "string" ? input.status : void 0,
+          limit: typeof input.limit === "number" ? input.limit : void 0
+        });
+      },
+      linkChat(taskId, input, idempotencyKey) {
+        return gateway.request({
+          path: `/api/platform/v1/tasks/${encodeURIComponent(
+            taskId
+          )}/link-chat`,
+          method: "POST",
+          body: input,
+          idempotencyKey: idempotencyKey ?? randomIdempotencyKey()
+        }).then(exposeGatewayData);
       }
     },
     topics: {
@@ -8707,11 +9001,13 @@ function createLucernClient(config = {}) {
     graphAnalysis: graphAnalysisClient,
     graphRecommendations: graphRecommendationsClient,
     orgGraphSearch: orgGraphSearchClient,
-    ontologyLinks: ontologyLinksClient,
+    ontologyLinks: ontologyLinksNamespace,
     graphStateClassifier: graphStateClassifierClient,
     modelRuntime: modelRuntimeClient,
     jobs: jobsClient,
     telemetry: telemetryClient,
+    publication: publicationNamespace,
+    contentPublication: publicationNamespace,
     tools: {
       listCatalog: toolRegistryClient.listCatalog,
       listExecutable: toolRegistryClient.listExecutable,
@@ -9438,6 +9734,14 @@ var ADD_WORKTREE = {
   description: "Check out a branch into an active worktree for investigation. Like `git worktree add <branch>` \u2014 creates independent working state on a thematic branch. Beliefs committed within the worktree can be freely amended (draft code on a feature branch). When investigation is complete, `merge` integrates findings into main.",
   parameters: {
     title: { type: "string", description: "Worktree name/objective" },
+    name: {
+      type: "string",
+      description: "Optional storage-name alias for callers that already use backend naming"
+    },
+    projectId: {
+      type: "string",
+      description: "Legacy topicId alias"
+    },
     topicId: { type: "string", description: "Optional topic scope hint" },
     branchId: {
       type: "string",
@@ -9451,14 +9755,87 @@ var ADD_WORKTREE = {
       type: "string",
       description: "The testable claim this worktree investigates"
     },
+    rationale: {
+      type: "string",
+      description: "Why this worktree exists and why it belongs in the campaign"
+    },
+    worktreeType: {
+      type: "string",
+      description: "Schema-enum worktree type used by the kernel lifecycle and retrieval layers"
+    },
+    gate: {
+      type: "string",
+      description: "Exit gate name for this worktree"
+    },
+    startDate: {
+      type: "number",
+      description: "Planned start timestamp in milliseconds since epoch"
+    },
+    endDate: {
+      type: "number",
+      description: "Planned end timestamp in milliseconds since epoch"
+    },
+    durationWeeks: {
+      type: "number",
+      description: "Planned duration in weeks"
+    },
+    confidenceImpact: {
+      type: "string",
+      description: "Expected confidence impact if the worktree succeeds",
+      enum: ["high", "medium", "low"]
+    },
+    beliefFocus: {
+      type: "string",
+      description: "Natural-language focus spanning the target belief neighborhood"
+    },
     beliefIds: {
       type: "array",
-      description: "Beliefs to test in this worktree"
+      description: "Legacy alias for targetBeliefIds"
+    },
+    beliefs: {
+      type: "array",
+      description: "Legacy alias for targetBeliefIds"
+    },
+    targetBeliefIds: {
+      type: "array",
+      description: "Belief node IDs this worktree is expected to test or update"
+    },
+    targetQuestionIds: {
+      type: "array",
+      description: "Question node IDs this worktree is expected to answer"
+    },
+    keyQuestions: {
+      type: "array",
+      description: "Inline key question objects with question, optional status, answer, answerConfidence, and linkedQuestionId"
+    },
+    evidenceSignals: {
+      type: "array",
+      description: "Evidence signal objects with signal, optional collected state, progress, and notes"
+    },
+    decisionGate: {
+      type: "object",
+      description: "Decision gate object with goCriteria, noGoSignals, optional verdict, rationale, decidedAt, and decidedBy"
+    },
+    goCriteria: {
+      type: "array",
+      description: "Shorthand go criteria used to build decisionGate"
+    },
+    noGoSignals: {
+      type: "array",
+      description: "Shorthand no-go signals used to build decisionGate"
+    },
+    proofArtifacts: {
+      type: "array",
+      description: "Expected proof artifacts required to close the worktree"
     },
     autoShape: {
       type: "boolean",
       description: "Whether to invoke inquiry auto-shaping during worktree creation"
     },
+    autoFixPolicy: {
+      type: "object",
+      description: "Policy for permitted automatic remediation inside the worktree"
+    },
     domainPackId: {
       type: "string",
       description: "Optional domain pack whose shaping hooks should influence generated questions and tasks"
@@ -9487,9 +9864,17 @@ var ADD_WORKTREE = {
       type: "array",
       description: "Worktree IDs blocked by this worktree"
     },
-    gate: {
+    staffingHint: {
       type: "string",
-      description: "Exit gate name for this worktree"
+      description: "Suggested staffing or agent allocation note"
+    },
+    lensId: {
+      type: "string",
+      description: "Lens that scopes this worktree when applicable"
+    },
+    lastReconciledAt: {
+      type: "number",
+      description: "Timestamp when worktree metadata was last reconciled"
     }
   },
   required: ["title", "topicId"],
@@ -9519,7 +9904,7 @@ var MERGE = {
     worktreeId: { type: "string", description: "The worktree to merge" },
     outcomes: {
       type: "array",
-      description: "Scoring outcomes for each belief: { beliefId, confidence, rationale }"
+      description: "Merge outcomes as key-finding strings, or scoring outcomes for beliefs: { beliefId, confidence, rationale }"
     },
     summary: { type: "string", description: "Overall findings summary" }
   },
@@ -12538,6 +12923,69 @@ var GENERATE_SESSION_HANDOFF = {
   tier: "showcase",
   internal: true
 };
+var BEGIN_BUILD_SESSION = {
+  name: "begin_build_session",
+  description: "Bootstrap a coding build session for a Lucern worktree. Like `git worktree add` plus `git status` \u2014 returns the compact context packet an agent needs before editing.",
+  parameters: {
+    worktreeId: {
+      type: "string",
+      description: "The Lucern worktree ID to bootstrap."
+    },
+    branch: {
+      type: "string",
+      description: "Optional git branch name. Auto-generated from the worktree name when omitted."
+    },
+    branchBase: {
+      type: "string",
+      description: 'Base branch for the feature branch. Default: "staging".'
+    },
+    prBase: {
+      type: "string",
+      description: 'Target branch for the PR. Default: "staging".'
+    },
+    sessionMode: {
+      type: "string",
+      description: 'Session mode: "async" for Codex/headless or "interactive" for live sessions.',
+      enum: ["async", "interactive"]
+    },
+    activateIfPlanning: {
+      type: "boolean",
+      description: "When true, automatically activate a planning worktree during bootstrap."
+    }
+  },
+  required: ["worktreeId"],
+  response: {
+    description: "A compact build-session packet with worktree metadata, graph anchors, questions, dependencies, and git defaults.",
+    fields: {
+      topicId: "string \u2014 canonical topic scope",
+      topicName: "string \u2014 human-readable topic name",
+      worktreeId: "string \u2014 worktree ID",
+      worktreeName: "string \u2014 human-readable worktree name",
+      branch: "string \u2014 git branch name",
+      branchBase: "string \u2014 base branch",
+      prBase: "string \u2014 PR target branch",
+      campaign: "number | null \u2014 top-level pipeline campaign",
+      lane: "string \u2014 campaign lane",
+      gate: "string \u2014 exit gate",
+      hypothesis: "string \u2014 worktree hypothesis",
+      focus: "string \u2014 session focus",
+      status: "string \u2014 worktree status after optional activation",
+      sessionMode: "string \u2014 async | interactive",
+      targetBeliefIds: "array \u2014 scoped belief IDs",
+      targetQuestionIds: "array \u2014 scoped question IDs",
+      topBeliefs: "array \u2014 highest-confidence scoped beliefs",
+      openQuestions: "array \u2014 open scoped questions",
+      resolvedDecisions: "array \u2014 answered questions summarized for the session",
+      dependencies: "array \u2014 upstream worktrees",
+      unblocks: "array \u2014 downstream worktrees",
+      mergeOrderNotes: "string \u2014 merge ordering advisory"
+    }
+  },
+  ownerModule: "bootstrap",
+  ontologyPrimitive: "worktree",
+  tier: "showcase",
+  internal: true
+};
 var MCP_TOOL_CONTRACTS = {
   // Belief lifecycle (commit, amend, fork, archive)
   create_belief: CREATE_BELIEF,
@@ -12631,6 +13079,7 @@ var MCP_TOOL_CONTRACTS = {
   get_agent_inbox: GET_AGENT_INBOX,
   claim_files: CLAIM_FILES,
   generate_session_handoff: GENERATE_SESSION_HANDOFF,
+  begin_build_session: BEGIN_BUILD_SESSION,
   // Policy / ACL (workhorse)
   check_permission: CHECK_PERMISSION,
   filter_by_permission: FILTER_BY_PERMISSION,
@@ -12844,6 +13293,7 @@ var PLATFORM_INTERNAL_OPERATION_NAMES = [
   "get_change_history",
   "get_failure_log",
   "record_attempt",
+  "begin_build_session",
   "push",
   "open_pull_request",
   "record_judgment",
@@ -12898,7 +13348,6 @@ var SDK_ONLY_OPERATION_NAMES = [
   "find_semantic_orphans"
 ];
 var MCP_ONLY_INTERNAL_OPERATION_NAMES = [
-  "begin_build_session",
   "evaluate_engineering_contract",
   "evaluate_research_contract"
 ];
@@ -12997,629 +13446,6 @@ var LUCERN_OPERATION_MANIFEST = {
 };
 globalThis.process?.env;
 
-// src/execution.ts
-var SCOPE_ALIAS_GROUPS = [];
-function createToolExecutionEnvelope(args) {
-  return {
-    toolName: args.toolName,
-    params: args.params,
-    contract: args.contract,
-    transport: {
-      kind: args.transportKind,
-      surface: args.transportKind === "chat" ? "chat" : "mcp",
-      normalizedAt: "handler_boundary"
-    },
-    auth: {
-      mode: args.authMode
-    },
-    policy: {
-      requiredScopes: args.requiredScopes,
-      enforcement: "gateway"
-    },
-    audit: {
-      source: "gateway_envelope",
-      structuralFields: [
-        "toolName",
-        "code",
-        "status",
-        "correlationId",
-        "policyTraceId",
-        "invariant"
-      ]
-    }
-  };
-}
-function hasValue(value) {
-  if (value === void 0 || value === null) {
-    return false;
-  }
-  if (typeof value === "string") {
-    return value.trim().length > 0;
-  }
-  if (Array.isArray(value)) {
-    return value.length > 0;
-  }
-  return true;
-}
-function normalizeToolExecutionParams(params) {
-  const normalized = { ...params };
-  for (const aliases of SCOPE_ALIAS_GROUPS) {
-    const sourceKey = aliases.find((key) => hasValue(normalized[key]));
-    if (!sourceKey) {
-      continue;
-    }
-    for (const key of aliases) {
-      if (!hasValue(normalized[key])) {
-        normalized[key] = normalized[sourceKey];
-      }
-    }
-  }
-  return normalized;
-}
-function parseToolExecutionMetadata(result) {
-  const raw = result.content[0]?.text;
-  if (!raw) {
-    return { isError: Boolean(result.isError) };
-  }
-  try {
-    const payload = JSON.parse(raw);
-    return {
-      isError: Boolean(result.isError),
-      code: typeof payload.code === "string" ? payload.code : void 0,
-      status: typeof payload.status === "number" ? payload.status : void 0,
-      correlationId: typeof payload.correlationId === "string" || payload.correlationId === null ? payload.correlationId : void 0,
-      policyTraceId: typeof payload.policyTraceId === "string" || payload.policyTraceId === null ? payload.policyTraceId : void 0,
-      invariant: typeof payload.invariant === "string" || payload.invariant === null ? payload.invariant : void 0
-    };
-  } catch {
-    return { isError: Boolean(result.isError) };
-  }
-}
-async function executeToolWithEnvelope(args) {
-  await args.hooks?.onEnvelope?.(args.envelope);
-  const result = await args.execute();
-  const metadata = parseToolExecutionMetadata(result);
-  await args.hooks?.onAuditEvent?.({
-    toolName: args.envelope.toolName,
-    contractName: args.envelope.contract.name,
-    transportKind: args.envelope.transport.kind,
-    authMode: args.envelope.auth.mode,
-    requiredScopes: args.envelope.policy.requiredScopes,
-    source: args.envelope.audit.source,
-    ...metadata
-  });
-  return result;
-}
-
-// src/types.ts
-var McpHandlerError = class extends Error {
-  code;
-  status;
-  suggestion;
-  constructor(message, code = "INVALID_REQUEST", status = 400, suggestion) {
-    super(message);
-    this.name = "McpHandlerError";
-    this.code = code;
-    this.status = status;
-    this.suggestion = suggestion;
-  }
-};
-
-// src/handler-factory.ts
-function isMissing(value) {
-  if (value === void 0 || value === null) {
-    return true;
-  }
-  if (typeof value === "string") {
-    return value.trim().length === 0;
-  }
-  if (Array.isArray(value)) {
-    return value.length === 0;
-  }
-  return false;
-}
-function readString3(params, key, options = {}) {
-  const value = params[key];
-  if (value === void 0 || value === null) {
-    if (options.required) {
-      throw new McpHandlerError(`Missing required parameter: ${key}`);
-    }
-    return;
-  }
-  if (typeof value !== "string") {
-    throw new McpHandlerError(`Expected string parameter: ${key}`);
-  }
-  const trimmed = value.trim();
-  if (!trimmed && options.required) {
-    throw new McpHandlerError(`Missing required parameter: ${key}`);
-  }
-  return trimmed || void 0;
-}
-function readNumber2(params, key, options = {}) {
-  const value = params[key];
-  if (value === void 0 || value === null) {
-    if (options.required) {
-      throw new McpHandlerError(`Missing required parameter: ${key}`);
-    }
-    return;
-  }
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new McpHandlerError(`Expected numeric parameter: ${key}`);
-  }
-  return value;
-}
-function readBoolean(params, key, options = {}) {
-  const value = params[key];
-  if (value === void 0 || value === null) {
-    if (options.required) {
-      throw new McpHandlerError(`Missing required parameter: ${key}`);
-    }
-    return;
-  }
-  if (typeof value !== "boolean") {
-    throw new McpHandlerError(`Expected boolean parameter: ${key}`);
-  }
-  return value;
-}
-function readStringArray(params, key) {
-  const value = params[key];
-  if (value === void 0 || value === null) {
-    return;
-  }
-  if (!Array.isArray(value)) {
-    throw new McpHandlerError(`Expected array parameter: ${key}`);
-  }
-  const values = value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0);
-  return values.length > 0 ? values : void 0;
-}
-function readTopicId4(params, options = {}) {
-  const value = params.topicId;
-  if (value === void 0 || value === null) {
-    if (options.required) {
-      throw new McpHandlerError("Missing required parameter: topicId");
-    }
-    return;
-  }
-  if (typeof value !== "string") {
-    throw new McpHandlerError("Expected string parameter: topicId");
-  }
-  const trimmed = value.trim();
-  if (!trimmed && options.required) {
-    throw new McpHandlerError("Missing required parameter: topicId");
-  }
-  return trimmed || void 0;
-}
-function toMcpResult(payload) {
-  return {
-    content: [{ type: "text", text: JSON.stringify(payload) }]
-  };
-}
-function toMcpError(error) {
-  if (error instanceof McpHandlerError) {
-    return {
-      isError: true,
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            code: error.code,
-            status: error.status,
-            message: error.message,
-            suggestion: error.suggestion ?? null
-          })
-        }
-      ]
-    };
-  }
-  if (error instanceof LucernApiError) {
-    return {
-      isError: true,
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            code: error.code,
-            status: error.status,
-            message: error.message,
-            invariant: error.invariant ?? null,
-            suggestion: error.suggestion ?? null,
-            correlationId: error.correlationId,
-            policyTraceId: error.policyTraceId
-          })
-        }
-      ]
-    };
-  }
-  const message = error instanceof Error ? error.message : "Tool execution failed.";
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          code: "INTERNAL_ERROR",
-          status: 500,
-          message
-        })
-      }
-    ]
-  };
-}
-function createNotImplementedHandler(name) {
-  return async () => toMcpError(
-    new McpHandlerError(
-      `Tool not implemented yet: ${name}`,
-      "NOT_IMPLEMENTED",
-      501
-    )
-  );
-}
-function validateRequired(params, contract) {
-  for (const key of contract.required) {
-    if (isMissing(params[key])) {
-      throw new McpHandlerError(`Missing required parameter: ${key}`);
-    }
-  }
-}
-function contractToHandler(contract, executor) {
-  return async (params) => {
-    try {
-      validateRequired(params, contract);
-      const payload = await executor(params);
-      return toMcpResult(payload);
-    } catch (error) {
-      return toMcpError(error);
-    }
-  };
-}
-
-// src/handlers/beliefs.ts
-var AMBIGUOUS_SCALAR_SUGGESTION = "Use opinion tuple (b, d, u, a) or an @lucern/sdk opinionFromBaseRate/opinionFromDogmatic/opinionFromProjected helper.";
-function readOpinionTuple(params) {
-  const belief = readNumber2(params, "belief");
-  const disbelief = readNumber2(params, "disbelief");
-  const uncertainty = readNumber2(params, "uncertainty");
-  const baseRate = readNumber2(params, "baseRate");
-  const tupleValues = [belief, disbelief, uncertainty, baseRate];
-  const providedCount = tupleValues.filter(
-    (value) => value !== void 0
-  ).length;
-  if (providedCount === 0) {
-    if (readNumber2(params, "confidence") !== void 0) {
-      throw new McpHandlerError(
-        "Scalar confidence input is ambiguous without an explicit subjective-logic interpretation.",
-        "AMBIGUOUS_SCALAR",
-        400,
-        AMBIGUOUS_SCALAR_SUGGESTION
-      );
-    }
-    throw new McpHandlerError(
-      "Missing required opinion tuple: belief, disbelief, uncertainty, and baseRate are required.",
-      "INVALID_REQUEST",
-      400
-    );
-  }
-  if (providedCount !== tupleValues.length) {
-    throw new McpHandlerError(
-      "Incomplete opinion tuple: belief, disbelief, uncertainty, and baseRate must all be provided together.",
-      "INVALID_REQUEST",
-      400
-    );
-  }
-  return {
-    b: belief,
-    d: disbelief,
-    u: uncertainty,
-    a: baseRate
-  };
-}
-function createBeliefHandlers(context) {
-  const beliefs = createBeliefsClient(context.sdkConfig);
-  const graph = createGraphClient(context.sdkConfig);
-  return {
-    create_belief: contractToHandler(
-      MCP_TOOL_CONTRACTS.create_belief,
-      async (params) => {
-        const result = await beliefs.createBelief({
-          canonicalText: readString3(params, "canonicalText", {
-            required: true
-          }),
-          topicId: readTopicId4(params, { required: true }),
-          layer: readString3(params, "layer"),
-          domain: readString3(params, "domain"),
-          subtype: readString3(params, "nodeType"),
-          baseRate: readNumber2(params, "baseRate", { required: true })
-        });
-        return {
-          nodeId: result.data.nodeId,
-          globalId: result.data.globalId,
-          status: result.data.status ?? "unscored"
-        };
-      }
-    ),
-    refine_belief: contractToHandler(
-      MCP_TOOL_CONTRACTS.refine_belief,
-      async (params) => {
-        const nodeId = readString3(params, "nodeId", { required: true });
-        const canonicalText = readString3(params, "canonicalText", {
-          required: true
-        });
-        const rationale = readString3(params, "rationale");
-        const result = await beliefs.refineBelief(nodeId, {
-          canonicalText,
-          rationale
-        });
-        return {
-          nodeId: result.data.nodeId ?? nodeId,
-          canonicalText: result.data.canonicalText ?? canonicalText,
-          updatedAt: result.data.updatedAt ?? Date.now()
-        };
-      }
-    ),
-    modulate_confidence: contractToHandler(
-      MCP_TOOL_CONTRACTS.modulate_confidence,
-      async (params) => {
-        const nodeId = readString3(params, "nodeId", { required: true });
-        const opinion = readOpinionTuple(params);
-        const result = await beliefs.modulateConfidence(nodeId, {
-          opinion,
-          trigger: readString3(params, "trigger", { required: true }),
-          rationale: readString3(params, "rationale", { required: true }),
-          triggeringEvidenceId: readString3(params, "triggeringEvidenceId"),
-          triggeringQuestionId: readString3(params, "triggeringQuestionId"),
-          triggeringAnswerId: readString3(params, "triggeringAnswerId"),
-          triggeringContradictionId: readString3(
-            params,
-            "triggeringContradictionId"
-          ),
-          triggeringWorktreeId: readString3(params, "triggeringWorktreeId")
-        });
-        return {
-          nodeId,
-          newConfidence: result.data.newConfidence ?? result.data.confidence ?? opinion.b + opinion.a * opinion.u,
-          previousConfidence: result.data.previousConfidence ?? null,
-          trigger: readString3(params, "trigger", { required: true })
-        };
-      }
-    ),
-    fork_belief: contractToHandler(
-      MCP_TOOL_CONTRACTS.fork_belief,
-      async (params) => {
-        const nodeId = readString3(params, "nodeId", { required: true });
-        const forkReason = readString3(params, "forkReason", {
-          required: true
-        });
-        const result = await beliefs.forkBelief(nodeId, {
-          newFormulation: readString3(params, "newFormulation", {
-            required: true
-          }),
-          forkReason
-        });
-        return {
-          nodeId: result.data.nodeId,
-          parentNodeId: result.data.parentNodeId ?? nodeId,
-          forkReason: result.data.forkReason ?? forkReason
-        };
-      }
-    ),
-    archive_belief: contractToHandler(
-      MCP_TOOL_CONTRACTS.archive_belief,
-      async (params) => {
-        const nodeId = readString3(params, "nodeId", { required: true });
-        const rationale = readString3(params, "rationale");
-        const result = await graph.updateNode({
-          nodeId,
-          status: "archived",
-          metadata: rationale ? {
-            archiveRationale: rationale
-          } : void 0
-        });
-        return {
-          nodeId: result.data.nodeId ?? nodeId,
-          status: "archived"
-        };
-      }
-    )
-  };
-}
-
-// src/handlers/context.ts
-function createContextHandlers(context) {
-  const compiler = createContextClient(context.sdkConfig);
-  return {
-    compile_context: contractToHandler(
-      MCP_TOOL_CONTRACTS.compile_context,
-      async (params) => {
-        const response = await compiler.compile(
-          readTopicId4(params, { required: true }),
-          {
-            ...readString3(params, "query") ? { query: readString3(params, "query") } : {},
-            ...readNumber2(params, "budget") !== void 0 ? { budget: readNumber2(params, "budget") } : {},
-            ...readString3(params, "ranking") ? {
-              ranking: readString3(params, "ranking")
-            } : {},
-            ...readNumber2(params, "limit") !== void 0 ? { limit: readNumber2(params, "limit") } : {},
-            ...readNumber2(params, "maxDepth") !== void 0 ? { maxDepth: readNumber2(params, "maxDepth") } : {},
-            ...readBoolean(params, "includeEntities") !== void 0 ? { includeEntities: readBoolean(params, "includeEntities") } : {}
-          }
-        );
-        return response.data;
-      }
-    )
-  };
-}
-
-// src/handlers/contradictions.ts
-function createContradictionHandlers(context) {
-  const lucern = createLucernClient(context.sdkConfig);
-  return {
-    flag_contradiction: contractToHandler(
-      MCP_TOOL_CONTRACTS.flag_contradiction,
-      async (params) => {
-        const beliefA = readString3(params, "beliefA", { required: true });
-        const beliefB = readString3(params, "beliefB", { required: true });
-        const description = readString3(params, "description", {
-          required: true
-        });
-        const topicId = readTopicId4(params, { required: true });
-        const severity = readString3(params, "severity") ?? "medium";
-        const defeatType = readString3(params, "defeatType") ?? "rebuts";
-        const contradiction = await lucern.contradictions.flag({
-          beliefA,
-          beliefB,
-          description,
-          topicId,
-          severity,
-          defeatType
-        });
-        return {
-          contradictionId: contradiction.contradictionId,
-          status: contradiction.status,
-          beliefA: contradiction.beliefA,
-          beliefB: contradiction.beliefB
-        };
-      }
-    )
-  };
-}
-
-// src/handlers/edges.ts
-function createEdgeHandlers(context) {
-  const lucern = createLucernClient(context.sdkConfig);
-  return {
-    create_edge: contractToHandler(
-      MCP_TOOL_CONTRACTS.create_edge,
-      async (params) => {
-        const sourceId = readString3(params, "sourceId", { required: true });
-        const targetId = readString3(params, "targetId", { required: true });
-        const edgeType = readString3(params, "edgeType", { required: true });
-        const confidence = readNumber2(params, "confidence");
-        const weight = readNumber2(params, "weight");
-        const contextText = readString3(params, "context") ?? readString3(params, "reasoning");
-        const edge = await lucern.edges.create({
-          sourceId,
-          targetId,
-          edgeType,
-          confidence,
-          weight,
-          context: contextText
-        });
-        return {
-          globalId: edge.globalId ?? edge.edgeId ?? "",
-          edgeType: edge.edgeType ?? edgeType,
-          fromLayer: edge.fromLayer ?? "unknown",
-          toLayer: edge.toLayer ?? "unknown"
-        };
-      }
-    )
-  };
-}
-
-// src/handlers/evidence.ts
-function readMetadata(params) {
-  const metadata = params.metadata;
-  return metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : void 0;
-}
-function createEvidenceHandlers(context) {
-  const lucern = createLucernClient(context.sdkConfig);
-  return {
-    create_evidence: contractToHandler(
-      MCP_TOOL_CONTRACTS.create_evidence,
-      async (params) => {
-        const response = await lucern.evidence.create({
-          topicId: readTopicId4(params, { required: true }),
-          text: readString3(params, "text", { required: true }),
-          source: readString3(params, "source"),
-          targetId: readString3(params, "targetId"),
-          weight: readNumber2(params, "weight"),
-          metadata: readMetadata(params),
-          title: readString3(params, "title"),
-          content: readString3(params, "content"),
-          contentType: readString3(params, "contentType"),
-          kind: readString3(params, "kind")
-        });
-        return response.data;
-      }
-    ),
-    get_evidence: contractToHandler(
-      MCP_TOOL_CONTRACTS.get_evidence,
-      async (params) => {
-        const response = await lucern.evidence.get(
-          readString3(params, "id", { required: true })
-        );
-        return response.data;
-      }
-    ),
-    list_evidence: contractToHandler(
-      MCP_TOOL_CONTRACTS.list_evidence,
-      async (params) => {
-        const response = await lucern.evidence.list({
-          topicId: readTopicId4(params),
-          targetId: readString3(params, "targetId"),
-          limit: readNumber2(params, "limit"),
-          cursor: readString3(params, "cursor")
-        });
-        return response.data;
-      }
-    ),
-    link_evidence: contractToHandler(
-      MCP_TOOL_CONTRACTS.link_evidence,
-      async (params) => {
-        const response = await lucern.evidence.link({
-          evidenceId: readString3(params, "evidenceId", { required: true }),
-          targetId: readString3(params, "targetId", { required: true }),
-          weight: readNumber2(params, "weight"),
-          rationale: readString3(params, "rationale")
-        });
-        return response.data;
-      }
-    ),
-    search_evidence: contractToHandler(
-      MCP_TOOL_CONTRACTS.search_evidence,
-      async (params) => {
-        const response = await lucern.evidence.search({
-          q: readString3(params, "q") ?? readString3(params, "query", { required: true }),
-          topicId: readTopicId4(params),
-          targetId: readString3(params, "targetId"),
-          limit: readNumber2(params, "limit"),
-          cursor: readString3(params, "cursor")
-        });
-        return response.data;
-      }
-    ),
-    add_evidence: contractToHandler(
-      MCP_TOOL_CONTRACTS.add_evidence,
-      async (params) => {
-        return lucern.evidence.add({
-          canonicalText: readString3(params, "canonicalText", { required: true }),
-          topicId: readTopicId4(params, { required: true }),
-          sourceUrl: readString3(params, "sourceUrl"),
-          supports: {
-            nodeId: readString3(params, "targetNodeId", { required: true }),
-            weight: readNumber2(params, "weight") ?? 1,
-            reasoning: readString3(params, "reasoning")
-          },
-          title: readString3(params, "title"),
-          content: readString3(params, "content"),
-          contentType: readString3(params, "contentType"),
-          metadata: readMetadata(params)
-        });
-      }
-    ),
-    link_evidence_to_belief: contractToHandler(
-      MCP_TOOL_CONTRACTS.link_evidence_to_belief,
-      async (params) => {
-        return lucern.evidence.linkToBelief({
-          evidenceId: readString3(params, "evidenceId", { required: true }),
-          beliefId: readString3(params, "beliefId", { required: true }),
-          weight: readNumber2(params, "weight", { required: true }),
-          rationale: readString3(params, "rationale")
-        });
-      }
-    )
-  };
-}
-
 // ../contracts/src/dsl/defineTable.ts
 function defineTable(spec) {
   return spec;
@@ -17454,7 +17280,9 @@ defineTable({
     "defaultProjectVisibility": z.enum(["private", "team", "firm", "external", "public"]).optional(),
     "deployments": z.record(z.object({
       "url": z.string(),
-      "encryptedDeployKey": z.string()
+      "target": z.enum(["kernelDeployment", "appDeployment"]).optional(),
+      "encryptedDeployKey": z.string().optional(),
+      "credentialRef": z.string().optional()
     })).optional(),
     "metadata": z.record(z.any()).optional(),
     "createdBy": z.string().optional(),
@@ -18517,8 +18345,31 @@ function assertSurfaceCoverage(contracts) {
     }
   }
 }
-
-// ../contracts/src/function-registry/context.ts
+var jsonRecordSchema2 = z.record(z.unknown());
+var observationArgs = z.object({
+  topicId: z.string().optional().describe("Topic scope for the observation."),
+  summary: z.string().describe("Short observation summary."),
+  text: z.string().optional().describe("Canonical observation text alias."),
+  title: z.string().optional().describe("Optional observation title."),
+  content: z.string().optional().describe("Optional rich observation content."),
+  contentType: z.string().optional().describe("Observation content type."),
+  kind: z.string().optional().describe("Evidence kind to store."),
+  observationType: z.string().optional().describe("Observation type."),
+  tags: z.array(z.string()).optional().describe("Observation tags."),
+  source: z.string().optional().describe("Observation source label."),
+  sourceType: z.string().optional().describe("Evidence source type."),
+  externalSourceType: z.string().optional().describe("External source type for imported observations."),
+  sourceUrl: z.string().optional().describe("Canonical source URL."),
+  confidence: z.number().optional().describe("Observation confidence."),
+  metadata: jsonRecordSchema2.optional().describe("Observation metadata."),
+  rationale: z.string().optional().describe("Why this observation should be recorded.")
+});
+var observationContextArgs = z.object({
+  topicId: z.string().describe("Topic scope."),
+  query: z.string().optional().describe("Optional context query."),
+  limit: z.number().optional().describe("Maximum observations to return."),
+  status: z.string().optional().describe("Observation status filter.")
+});
 var observationInput = (input, context) => withUserId(
   compactRecord4({
     projectId: input.projectId,
@@ -18577,7 +18428,8 @@ var contextContracts = [
         observationId: output && typeof output === "object" ? output.nodeId : void 0,
         observationType: input.observationType
       })
-    }
+    },
+    args: observationArgs
   }),
   surfaceContract({
     name: "get_observation_context",
@@ -18598,7 +18450,8 @@ var contextContracts = [
         status: input.status,
         userId: input.userId
       })
-    }
+    },
+    args: observationContextArgs
   })
 ];
 
@@ -18661,8 +18514,45 @@ var identityContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/beliefs.ts
+var jsonRecordSchema3 = z.record(z.unknown());
+var sourceTypeSchema = z.enum(["human", "ai_extracted", "ai_generated"]);
+var reversibilitySchema = z.enum([
+  "irreversible",
+  "hard_to_reverse",
+  "reversible",
+  "trivial"
+]);
+var predictionMetaSchema = z.object({
+  isPrediction: z.boolean().describe("Whether this belief is a prediction."),
+  registeredAt: z.number().describe("Timestamp when the prediction was registered."),
+  expectedBy: z.number().optional().describe("Timestamp when the prediction should be evaluated.")
+});
+var createBeliefArgs = z.object({
+  canonicalText: z.string().describe("The belief statement the agent holds to be true."),
+  topicId: z.string().optional().describe("Topic scope hint for the belief."),
+  baseRate: z.number().optional().describe("Prior base rate used to seed the vacuous opinion."),
+  beliefType: z.string().optional().describe("Schema belief type."),
+  metadata: jsonRecordSchema3.optional().describe("Extra metadata merged into the belief node."),
+  rationale: z.string().optional().describe("Why this belief should enter the reasoning graph."),
+  pillar: z.string().optional().describe("Innovation pillar or product pillar associated with the belief."),
+  worktreeId: z.string().optional().describe("Worktree responsible for creating or testing this belief."),
+  sourceBeliefIds: z.array(z.string()).optional().describe("Source belief IDs this belief derives from."),
+  sourceType: sourceTypeSchema.optional().describe("Actor/source class that produced the belief."),
+  reversibility: reversibilitySchema.optional().describe("How reversible the belief's implied decision is."),
+  predictionMeta: predictionMetaSchema.optional().describe("Prediction lifecycle metadata when this belief is a forecast.")
+});
+var forkBeliefArgs = z.object({
+  nodeId: z.string().describe("The scored belief to fork from."),
+  newFormulation: z.string().describe("The evolved belief statement."),
+  forkReason: z.enum([
+    "refinement",
+    "contradiction_response",
+    "scope_change",
+    "confidence_collapse",
+    "manual"
+  ]).describe("Why this fork was created."),
+  rationale: z.string().optional().describe("Why the fork is warranted.")
+});
 var beliefLookupInput = (input) => compactRecord4({
   nodeId: input.nodeId ?? input.id ?? input.beliefId,
   beliefId: input.beliefId
@@ -18737,7 +18627,8 @@ var beliefsContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: createBeliefInput
-    }
+    },
+    args: createBeliefArgs
   }),
   surfaceContract({
     name: "get_belief",
@@ -18828,7 +18719,8 @@ var beliefsContracts = [
       functionName: "forkBelief",
       kind: "mutation",
       inputProjection: forkBeliefInput
-    }
+    },
+    args: forkBeliefArgs
   }),
   surfaceContract({
     name: "archive_belief",
@@ -18909,8 +18801,46 @@ var beliefsContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/evidence.ts
+var jsonRecordSchema4 = z.record(z.unknown());
+var evidenceRelationSchema = z.enum(["supports", "contradicts", "neutral"]);
+var createEvidenceArgs = z.object({
+  topicId: z.string().optional().describe("Topic scope for the evidence."),
+  text: z.string().describe("Canonical evidence text."),
+  source: z.string().optional().describe("Source URL or source label."),
+  sourceUrl: z.string().optional().describe("Canonical source URL."),
+  targetId: z.string().optional().describe("Belief or question identifier to link immediately."),
+  linkedBeliefNodeId: z.string().optional().describe("Belief node this evidence bears on."),
+  evidenceRelation: evidenceRelationSchema.optional().describe("How the evidence relates to the linked belief."),
+  confidence: z.number().optional().describe("Confidence in the evidence relation."),
+  weight: z.number().optional().describe("Support weight from -1.0 to +1.0."),
+  metadata: jsonRecordSchema4.optional().describe("Metadata merged into the canonical evidence node."),
+  rationale: z.string().describe("Why this evidence should enter the reasoning graph."),
+  reasoning: z.string().optional().describe("Reasoning note preserved in evidence metadata."),
+  title: z.string().optional().describe("Optional short title."),
+  content: z.string().optional().describe("Optional long-form content."),
+  contentType: z.string().optional().describe("Content format or MIME hint."),
+  kind: z.string().optional().describe("Evidence kind."),
+  tags: z.array(z.string()).optional().describe("Evidence tags."),
+  sourceType: z.string().optional().describe("Evidence source type."),
+  externalSourceType: z.string().optional().describe("External source type for imported evidence."),
+  sourceQuestionId: z.string().optional().describe("Question that sourced this evidence."),
+  methodology: z.string().optional().describe("Collection methodology."),
+  informationAsymmetry: z.string().optional().describe("Information asymmetry class."),
+  sourceDescription: z.string().optional().describe("Human-readable source description.")
+});
+var addEvidenceArgs = z.object({
+  canonicalText: z.string().describe("The evidence statement."),
+  text: z.string().optional().describe("Canonical evidence text alias used by newer callers."),
+  topicId: z.string().optional().describe("Topic scope hint."),
+  sourceUrl: z.string().optional().describe("URL of the source material."),
+  targetNodeId: z.string().describe("The belief this evidence bears on."),
+  weight: z.number().optional().describe("Support weight from -1.0 to +1.0."),
+  reasoning: z.string().describe("Why this evidence is relevant to the target belief."),
+  title: z.string().optional().describe("Optional short title."),
+  content: z.string().optional().describe("Optional long-form evidence content."),
+  contentType: z.string().optional().describe("Content format or MIME hint."),
+  metadata: jsonRecordSchema4.optional().describe("Optional metadata merged into the evidence node.")
+});
 var evidenceIdInput = (input) => compactRecord4({
   evidenceId: input.evidenceId,
   insightId: input.insightId,
@@ -18985,7 +18915,8 @@ var evidenceContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: createEvidenceInput
-    }
+    },
+    args: createEvidenceArgs
   }),
   surfaceContract({
     name: "add_evidence",
@@ -19021,7 +18952,8 @@ var evidenceContracts = [
           context
         );
       }
-    }
+    },
+    args: addEvidenceArgs
   }),
   surfaceContract({
     name: "get_evidence",
@@ -19128,8 +19060,91 @@ var evidenceContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/questions.ts
+var jsonRecordSchema5 = z.record(z.unknown());
+var questionPrioritySchema = z.enum(["urgent", "high", "medium", "low"]);
+var kernelQuestionPrioritySchema = z.enum([
+  "critical",
+  "high",
+  "medium",
+  "low"
+]);
+var questionTypeSchema = z.enum([
+  "validation",
+  "falsification",
+  "assumption_probe",
+  "prediction_test",
+  "counterfactual",
+  "discovery",
+  "clarification",
+  "comparison",
+  "causal",
+  "mechanism",
+  "general"
+]);
+var createQuestionArgs = z.object({
+  text: z.string().describe("The question text."),
+  question: z.string().optional().describe("Backend question text alias for kernel-native callers."),
+  topicId: z.string().optional().describe("Topic scope hint."),
+  priority: questionPrioritySchema.optional().describe("Human-facing question priority."),
+  linkedBeliefId: z.string().optional().describe("Belief this question tests."),
+  linkedBeliefNodeId: z.string().optional().describe("Belief node this question tests."),
+  metadata: jsonRecordSchema5.optional().describe("Optional metadata merged into the question record."),
+  category: z.string().optional().describe("Question category."),
+  source: z.string().optional().describe("Question source."),
+  testType: z.enum(["validates", "invalidates", "clarifies"]).optional().describe("How this question tests its linked belief."),
+  importance: z.number().optional().describe("Numeric importance score."),
+  epistemicUnlock: z.string().optional().describe("What this question unlocks if answered."),
+  sourceQuestionIds: z.array(z.string()).optional().describe("Question IDs this question derives from."),
+  linkedWorktreeId: z.string().optional().describe("Worktree this question belongs to."),
+  questionType: questionTypeSchema.optional().describe("Question type."),
+  questionPriority: kernelQuestionPrioritySchema.optional().describe("Kernel-native question priority.")
+});
+var refineQuestionArgs = z.object({
+  id: z.string().describe("The question to refine."),
+  text: z.string().describe("Updated question text."),
+  question: z.string().optional().describe("Backend question text alias for kernel-native callers."),
+  rationale: z.string().optional().describe("Why the question is refined."),
+  category: z.string().optional().describe("Updated question category."),
+  priority: questionPrioritySchema.optional().describe("Updated human-facing priority.")
+});
+var createAnswerArgs = z.object({
+  questionNodeId: z.string().describe("The question node ID this answer responds to."),
+  questionId: z.string().optional().describe("Question ID alias accepted by the projection."),
+  answerText: z.string().describe("The answer content."),
+  topicId: z.string().optional().describe("Topic scope for the answer."),
+  confidence: z.string().optional().describe("Answer confidence."),
+  evidenceNodeIds: z.array(z.string()).optional().describe("Evidence node IDs supporting the answer."),
+  answerSource: z.string().optional().describe("How the answer was produced."),
+  worktreeId: z.string().optional().describe("Worktree whose outcome produced this answer."),
+  sprintId: z.string().optional().describe("Legacy sprint identifier.")
+});
+var answerQuestionArgs = z.object({
+  id: z.string().describe("Canonical question ID."),
+  topicId: z.string().describe("Topic scope for the answer."),
+  text: z.string().describe("Answer text."),
+  confidence: z.enum(["weak", "medium", "strong"]).optional().describe("Optional answer confidence."),
+  evidenceIds: z.array(z.string()).optional().describe("Canonical evidence IDs supporting the answer."),
+  rationale: z.string().optional().describe("Why this answer is credible."),
+  questionId: z.string().optional().describe("Question ID alias accepted by the projection."),
+  questionNodeId: z.string().optional().describe("Question node ID alias accepted by the projection."),
+  answerText: z.string().optional().describe("Canonical answer text alias accepted by newer callers."),
+  evidenceNodeIds: z.array(z.string()).optional().describe("Evidence node ID alias accepted by newer callers."),
+  answerSource: z.string().optional().describe("How the answer was produced."),
+  worktreeId: z.string().optional().describe("Worktree whose outcome produced this answer."),
+  sprintId: z.string().optional().describe("Legacy sprint identifier.")
+});
+var missingQuestionsArgs = z.object({
+  topicId: z.string().describe("Topic scope."),
+  minConfidence: z.number().optional().describe("Minimum confidence threshold for missing-question checks."),
+  status: z.string().optional().describe("Question status filter."),
+  limit: z.number().optional().describe("Maximum questions to inspect.")
+});
+var falsificationQuestionsArgs = z.object({
+  topicId: z.string().describe("Topic scope."),
+  beliefIds: z.array(z.string()).optional().describe("Beliefs to generate falsification questions for."),
+  status: z.string().optional().describe("Question status filter."),
+  limit: z.number().optional().describe("Maximum questions to inspect.")
+});
 var questionNodeInput = (input) => compactRecord4({
   nodeId: input.nodeId ?? input.id ?? input.questionId,
   questionId: input.questionId
@@ -19176,7 +19191,8 @@ var questionsContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: createQuestionInput
-    }
+    },
+    args: createQuestionArgs
   }),
   surfaceContract({
     name: "get_question",
@@ -19232,7 +19248,8 @@ var questionsContracts = [
         category: input.category,
         priority: input.priority
       })
-    }
+    },
+    args: refineQuestionArgs
   }),
   surfaceContract({
     name: "update_question_status",
@@ -19308,7 +19325,8 @@ var questionsContracts = [
         }),
         context
       )
-    }
+    },
+    args: createAnswerArgs
   }),
   surfaceContract({
     name: "answer_question",
@@ -19337,7 +19355,8 @@ var questionsContracts = [
         }),
         context
       )
-    }
+    },
+    args: answerQuestionArgs
   }),
   surfaceContract({
     name: "get_answer",
@@ -19369,7 +19388,8 @@ var questionsContracts = [
       functionName: "getByTopic",
       kind: "query",
       inputProjection: questionTopicInput
-    }
+    },
+    args: missingQuestionsArgs
   }),
   surfaceContract({
     name: "get_high_priority_questions",
@@ -19404,11 +19424,22 @@ var questionsContracts = [
       functionName: "getByTopic",
       kind: "query",
       inputProjection: questionTopicInput
-    }
+    },
+    args: falsificationQuestionsArgs
   })
 ];
-
-// ../contracts/src/function-registry/topics.ts
+var updateTopicArgs = z.object({
+  id: z.string().describe("Topic ID."),
+  topicId: z.string().optional().describe("Topic ID alias."),
+  name: z.string().optional().describe("Topic name."),
+  description: z.string().optional().describe("Topic description."),
+  type: z.string().optional().describe("Topic type."),
+  status: z.string().optional().describe("Topic status."),
+  visibility: z.string().optional().describe("Topic visibility."),
+  ontologyId: z.string().optional().describe("Ontology to bind."),
+  clearOntologyId: z.boolean().optional().describe("Whether to clear the ontology binding."),
+  metadata: z.record(z.unknown()).optional().describe("Topic metadata.")
+});
 var topicIdInput = (input) => compactRecord4({
   id: input.id ?? input.topicId
 });
@@ -19489,7 +19520,8 @@ var topicsContracts = [
       functionName: "update",
       kind: "mutation",
       inputProjection: updateTopicInput
-    }
+    },
+    args: updateTopicArgs
   }),
   surfaceContract({
     name: "get_topic_tree",
@@ -19508,8 +19540,27 @@ var topicsContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/lenses.ts
+var lensPerspectiveSchema = z.enum([
+  "investigation",
+  "monitoring",
+  "analysis",
+  "comparison",
+  "taxonomy"
+]);
+var jsonRecordSchema6 = z.record(z.unknown());
+var createLensArgs = z.object({
+  name: z.string().describe("Lens name."),
+  workspaceId: z.string().optional().describe("Workspace scope for the lens."),
+  topicId: z.string().optional().describe("Originating topic scope."),
+  description: z.string().optional().describe("What this lens investigates or monitors."),
+  perspectiveType: lensPerspectiveSchema.describe("Perspective type."),
+  promptTemplates: z.array(jsonRecordSchema6).optional().describe("Prompt templates used through this lens."),
+  workflowTemplates: z.array(jsonRecordSchema6).optional().describe("Guided workflow templates."),
+  taskTemplates: z.array(jsonRecordSchema6).optional().describe("Default task templates."),
+  questionTemplates: z.array(jsonRecordSchema6).optional().describe("Default question templates."),
+  filterCriteria: jsonRecordSchema6.optional().describe("Belief/evidence filtering criteria."),
+  metadata: jsonRecordSchema6.optional().describe("Additional lens metadata.")
+});
 var createLensInput = (input, context) => compactRecord4({
   name: input.name,
   description: input.description,
@@ -19546,7 +19597,8 @@ var lensesContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: createLensInput
-    }
+    },
+    args: createLensArgs
   }),
   surfaceContract({
     name: "list_lenses",
@@ -19608,8 +19660,18 @@ var lensesContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/ontologies.ts
+var updateOntologyArgs = z.object({
+  id: z.string().describe("Ontology definition ID."),
+  ontologyId: z.string().optional().describe("Ontology ID alias."),
+  name: z.string().optional().describe("Ontology display name."),
+  description: z.string().optional().describe("Ontology description."),
+  status: z.string().optional().describe("Ontology lifecycle status.")
+});
+var ontologyVersionLifecycleArgs = z.object({
+  id: z.string().describe("Ontology version ID."),
+  versionId: z.string().optional().describe("Ontology version ID alias."),
+  ontologyId: z.string().optional().describe("Ontology definition ID.")
+});
 var ontologyIdInput = (input) => compactRecord4({
   id: input.id ?? input.ontologyId
 });
@@ -19688,11 +19750,11 @@ var ontologiesContracts = [
         id: input.id ?? input.ontologyId,
         name: input.name,
         description: input.description,
-        parentOntologyId: input.parentOntologyId,
         status: input.status,
         actorId: input.actorId
       })
-    }
+    },
+    args: updateOntologyArgs
   }),
   surfaceContract({
     name: "archive_ontology",
@@ -19775,7 +19837,8 @@ var ontologiesContracts = [
       functionName: "publishOntologyVersion",
       kind: "mutation",
       inputProjection: ontologyVersionIdInput
-    }
+    },
+    args: ontologyVersionLifecycleArgs
   }),
   surfaceContract({
     name: "deprecate_ontology_version",
@@ -19791,7 +19854,8 @@ var ontologiesContracts = [
       functionName: "deprecateOntologyVersion",
       kind: "mutation",
       inputProjection: ontologyVersionIdInput
-    }
+    },
+    args: ontologyVersionLifecycleArgs
   }),
   surfaceContract({
     name: "resolve_effective_ontology",
@@ -19810,8 +19874,76 @@ var ontologiesContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/worktrees.ts
+var autoFixPolicyInputSchema = z.object({
+  enabled: z.boolean().optional().describe("Whether automatic remediation is enabled."),
+  mode: z.string().optional().describe("Automation mode for worktree auto-fixes."),
+  maxAttempts: z.number().optional().describe("Maximum number of auto-fix attempts."),
+  reviewer: z.string().optional().describe("Reviewer responsible for auto-fix oversight."),
+  maxActionsPerRun: z.number().optional().describe("Maximum number of auto-fix actions per run."),
+  permittedMutationTiers: z.array(z.enum(["read_only", "low_risk_write", "high_risk_write"])).optional().describe("Mutation tiers the auto-fix worker may execute."),
+  requireAuditTrail: z.boolean().optional().describe("Whether auto-fix actions must write an audit trail."),
+  escalationGate: z.string().optional().describe("Gate to trigger when auto-fix policy requires escalation.")
+}).passthrough().describe("Policy for permitted automatic remediation inside the worktree.");
+var worktreeKeyQuestionInputSchema = z.object({
+  question: z.string().describe("Question the worktree must resolve."),
+  status: z.enum(["open", "answered", "forked"]).optional().describe("Current disposition of the key question."),
+  answer: z.string().optional().describe("Captured answer when the key question is resolved."),
+  answerConfidence: z.enum(["high", "medium", "low"]).optional().describe("Confidence in the captured answer."),
+  linkedQuestionId: z.string().optional().describe("Canonical question node linked to this key question.")
+}).passthrough().describe("Question contract embedded in the worktree plan.");
+var worktreeEvidenceSignalInputSchema = z.object({
+  signal: z.string().describe("Evidence signal the worktree should collect."),
+  collected: z.boolean().optional().describe("Whether the signal has already been collected."),
+  progress: z.string().optional().describe("Collection progress note for the signal."),
+  notes: z.string().optional().describe("Additional evidence collection notes.")
+}).passthrough().describe("Evidence signal embedded in the worktree plan.");
+var worktreeDecisionGateInputSchema = z.object({
+  goCriteria: z.array(z.string()).describe("Criteria that must hold for the worktree to proceed."),
+  noGoSignals: z.array(z.string()).describe("Signals that stop or redirect the worktree."),
+  verdict: z.enum(["go", "no_go", "pivot", "pending"]).optional().describe("Current decision verdict for the worktree gate."),
+  verdictRationale: z.string().optional().describe("Rationale supporting the current gate verdict."),
+  decidedAt: z.number().optional().describe("Timestamp when the gate verdict was decided."),
+  decidedBy: z.string().optional().describe("Actor that decided the gate verdict.")
+}).passthrough().describe("Decision gate contract for worktree activation or exit.");
+var addWorktreeArgs = z.object({
+  title: z.string().optional().describe("Human-readable worktree name or objective."),
+  name: z.string().optional().describe("Storage-name alias for callers that already use backend naming."),
+  topicId: z.string().describe("Primary topic scope for the worktree."),
+  projectId: z.string().optional().describe("Legacy topicId alias."),
+  branchId: z.string().optional().describe("Legacy branch identifier for compatibility with workflow callers."),
+  objective: z.string().optional().describe("Reasoning objective this worktree is intended to resolve."),
+  hypothesis: z.string().optional().describe("Testable claim this worktree investigates."),
+  rationale: z.string().optional().describe("Why this worktree exists and why it belongs in the campaign."),
+  worktreeType: z.string().optional().describe("Schema-enum worktree type used for kernel lifecycle behavior."),
+  gate: z.string().optional().describe("Exit gate for this worktree."),
+  startDate: z.number().optional().describe("Planned start timestamp in milliseconds since epoch."),
+  endDate: z.number().optional().describe("Planned end timestamp in milliseconds since epoch."),
+  durationWeeks: z.number().optional().describe("Planned duration in weeks."),
+  confidenceImpact: z.enum(["high", "medium", "low"]).optional().describe("Expected confidence impact if this worktree succeeds."),
+  beliefFocus: z.string().optional().describe("Natural-language focus spanning the target belief neighborhood."),
+  beliefIds: z.array(z.string()).optional().describe("Legacy alias for targetBeliefIds."),
+  beliefs: z.array(z.string()).optional().describe("Legacy alias for targetBeliefIds."),
+  targetBeliefIds: z.array(z.string()).optional().describe("Belief node IDs this worktree is expected to test or update."),
+  targetQuestionIds: z.array(z.string()).optional().describe("Question node IDs this worktree is expected to answer."),
+  keyQuestions: z.array(worktreeKeyQuestionInputSchema).optional().describe("Inline key questions captured as part of the worktree plan."),
+  evidenceSignals: z.array(worktreeEvidenceSignalInputSchema).optional().describe("Evidence signals the worktree needs to collect or validate."),
+  decisionGate: worktreeDecisionGateInputSchema.optional(),
+  goCriteria: z.array(z.string()).optional().describe("Shorthand go criteria used to build decisionGate."),
+  noGoSignals: z.array(z.string()).optional().describe("Shorthand no-go signals used to build decisionGate."),
+  proofArtifacts: z.array(z.unknown()).optional().describe("Expected proof artifacts required to close the worktree."),
+  autoShape: z.boolean().optional().describe("Whether to invoke inquiry auto-shaping during creation."),
+  autoFixPolicy: autoFixPolicyInputSchema.optional(),
+  domainPackId: z.string().optional().describe("Domain pack whose shaping hooks should influence the worktree."),
+  campaign: z.number().optional().describe("Top-level pipeline campaign number."),
+  lane: z.string().optional().describe("Campaign lane for the worktree."),
+  laneOrderInCampaign: z.number().optional().describe("Ordering for this lane within its campaign."),
+  orderInLane: z.number().optional().describe("Position of this worktree inside its lane."),
+  dependsOn: z.array(z.string()).optional().describe("Worktree IDs that must complete before this worktree."),
+  blocks: z.array(z.string()).optional().describe("Worktree IDs blocked by this worktree."),
+  staffingHint: z.string().optional().describe("Suggested staffing or agent allocation note."),
+  lensId: z.string().optional().describe("Lens that scopes this worktree when applicable."),
+  lastReconciledAt: z.number().optional().describe("Timestamp when worktree metadata was last reconciled.")
+});
 var worktreeIdInput = (input) => compactRecord4({
   worktreeId: input.worktreeId ?? input.id
 });
@@ -19844,6 +19976,50 @@ var worktreeMetadataInput = (input) => compactRecord4({
   autoFixPolicy: input.autoFixPolicy,
   lastReconciledAt: input.lastReconciledAt
 });
+var worktreeMetadataArgs = z.object({
+  worktreeId: z.string().describe("The worktree to update."),
+  id: z.string().optional().describe("Worktree ID alias."),
+  topicId: z.string().optional().describe("Primary topic scope."),
+  additionalTopicIds: z.array(z.string()).optional().describe("Additional topic scopes associated with this worktree."),
+  status: z.string().optional().describe("Worktree lifecycle status."),
+  campaign: z.number().optional().describe("Top-level pipeline campaign."),
+  lane: z.string().optional().describe("Campaign lane."),
+  laneOrderInCampaign: z.number().optional().describe("Ordering for this lane within its campaign."),
+  orderInLane: z.number().optional().describe("Position of this worktree inside its lane."),
+  gate: z.string().optional().describe("Exit gate for this worktree."),
+  hypothesis: z.string().optional().describe("Testable claim this worktree investigates."),
+  objective: z.string().optional().describe("Reasoning objective for the worktree."),
+  rationale: z.string().optional().describe("Why this worktree is sequenced here."),
+  proofArtifacts: z.array(z.unknown()).optional().describe("Proof artifacts required to close the worktree."),
+  staffingHint: z.string().optional().describe("Suggested staffing or agent allocation note."),
+  blocks: z.array(z.string()).optional().describe("Worktree IDs blocked by this worktree."),
+  dependsOn: z.array(z.string()).optional().describe("Worktree IDs this worktree depends on."),
+  lensId: z.string().optional().describe("Lens that scopes this worktree."),
+  autoFixPolicy: autoFixPolicyInputSchema.optional(),
+  lastReconciledAt: z.number().optional().describe("Timestamp of the last deterministic reconciliation pass.")
+});
+var pushArgs = worktreeMetadataArgs.extend({
+  targetContext: z.string().describe("Where to push merged findings."),
+  beliefIds: z.array(z.string()).optional().describe("Optional subset of beliefs to push.")
+});
+var openPullRequestArgs = worktreeMetadataArgs.extend({
+  reviewers: z.array(z.string()).optional().describe("User IDs of requested reviewers."),
+  summary: z.string().describe("Summary of findings and why they are ready for review.")
+});
+var mergeKeyFindingsInput = (input) => {
+  if (Array.isArray(input.keyFindings)) {
+    return input.keyFindings;
+  }
+  if (Array.isArray(input.outcomes)) {
+    const findings = input.outcomes.filter(
+      (outcome) => typeof outcome === "string" && outcome.trim().length > 0
+    );
+    if (findings.length > 0) {
+      return findings;
+    }
+  }
+  return [input.summary ?? "Merged worktree"];
+};
 var listAllWorktreesInput = (input) => compactRecord4({
   status: input.status,
   lane: input.lane,
@@ -19851,6 +20027,16 @@ var listAllWorktreesInput = (input) => compactRecord4({
   limit: input.limit
 });
 var worktreesContracts = [
+  surfaceContract({
+    name: "begin_build_session",
+    kind: "mutation",
+    domain: "worktrees",
+    surfaceClass: "platform_internal",
+    path: "/mcp/build-session/begin",
+    sdkNamespace: "worktrees",
+    sdkMethod: "beginBuildSession",
+    summary: "Begin a coding build session for a worktree."
+  }),
   surfaceContract({
     name: "add_worktree",
     kind: "mutation",
@@ -19867,13 +20053,12 @@ var worktreesContracts = [
       inputProjection: (input, context) => withCreatedBy(
         compactRecord4({
           name: input.name ?? input.title,
-          topicId: input.topicId,
+          topicId: input.topicId ?? input.projectId,
           worktreeType: input.worktreeType,
           objective: input.objective,
           gate: input.gate,
           hypothesis: input.hypothesis,
           rationale: input.rationale,
-          signal: input.signal,
           startDate: input.startDate,
           endDate: input.endDate,
           durationWeeks: input.durationWeeks,
@@ -19899,12 +20084,12 @@ var worktreesContracts = [
           staffingHint: input.staffingHint,
           domainPackId: input.domainPackId,
           lensId: input.lensId,
-          linkedQuestionId: input.linkedQuestionId,
           lastReconciledAt: input.lastReconciledAt
         }),
         context
       )
-    }
+    },
+    args: addWorktreeArgs
   }),
   surfaceContract({
     name: "activate_worktree",
@@ -20016,7 +20201,8 @@ var worktreesContracts = [
       functionName: "updateMetadata",
       kind: "mutation",
       inputProjection: worktreeMetadataInput
-    }
+    },
+    args: worktreeMetadataArgs
   }),
   surfaceContract({
     name: "merge",
@@ -20034,9 +20220,7 @@ var worktreesContracts = [
       inputProjection: (input, context) => withUserId(
         {
           ...worktreeIdInput(input),
-          keyFindings: input.keyFindings ?? [
-            input.summary ?? "Merged worktree"
-          ],
+          keyFindings: mergeKeyFindingsInput(input),
           decisionsReached: input.decisionsReached ?? [],
           nextSteps: input.nextSteps ?? []
         },
@@ -20058,7 +20242,8 @@ var worktreesContracts = [
       functionName: "updateMetadata",
       kind: "mutation",
       inputProjection: worktreeMetadataInput
-    }
+    },
+    args: pushArgs
   }),
   surfaceContract({
     name: "open_pull_request",
@@ -20074,7 +20259,8 @@ var worktreesContracts = [
       functionName: "updateMetadata",
       kind: "mutation",
       inputProjection: worktreeMetadataInput
-    }
+    },
+    args: openPullRequestArgs
   })
 ];
 
@@ -20178,6 +20364,15 @@ var createEdgeArgs = z.object({
   topicId: z.string().optional(),
   trustedBypassAccessCheck: z.boolean().optional()
 });
+var queryLineageArgs = z.object({
+  nodeId: z.string().describe("Starting node to trace from."),
+  startNode: z.string().optional().describe("Starting node alias accepted by traversal callers."),
+  depth: z.number().optional().describe("Traversal depth alias."),
+  maxDepth: z.number().optional().describe("Maximum traversal depth."),
+  mode: z.string().optional().describe("Traversal mode."),
+  minLayer: z.string().optional().describe("Minimum epistemic layer."),
+  maxLayer: z.string().optional().describe("Maximum epistemic layer.")
+});
 function graphRefNodeId(ref) {
   if (ref.kind === "epistemic_node") {
     return ref.nodeId;
@@ -20248,11 +20443,59 @@ var edgesContracts = [
         minLayer: input.minLayer,
         maxLayer: input.maxLayer
       })
-    }
+    },
+    args: queryLineageArgs
   })
 ];
-
-// ../contracts/src/function-registry/graph.ts
+var traversalLayerSchema = z.enum([
+  "L4",
+  "L3",
+  "L2",
+  "L1",
+  "ontological",
+  "organizational"
+]);
+var traversalModeSchema = z.enum(["low", "medium", "high", "extra_high"]);
+var lineageAliasArgs = z.object({
+  nodeId: z.string().optional().describe("Starting node to traverse from."),
+  startNode: z.string().optional().describe("Starting node alias for traversal callers."),
+  entityId: z.string().optional().describe("Entity identifier alias for impact tracing."),
+  depth: z.number().optional().describe("Traversal depth alias."),
+  maxDepth: z.number().optional().describe("Maximum traversal depth."),
+  mode: traversalModeSchema.optional().describe("Traversal mode."),
+  minLayer: traversalLayerSchema.optional().describe("Minimum epistemic layer to include."),
+  maxLayer: traversalLayerSchema.optional().describe("Maximum epistemic layer to include.")
+});
+var lineageArgs = lineageAliasArgs.extend({
+  nodeId: z.string().describe("Starting node to traverse from.")
+});
+var traverseGraphArgs = lineageAliasArgs.extend({
+  startNode: z.string().describe("Node to start traversal from."),
+  direction: z.enum(["up", "down", "both"]).optional().describe("Traversal direction.")
+});
+var graphNeighborhoodArgs = z.object({
+  globalId: z.string().optional().describe("Single root global ID."),
+  globalIds: z.array(z.string()).optional().describe("Root global IDs for the neighborhood."),
+  maxDepth: z.number().optional().describe("Maximum traversal depth."),
+  topicId: z.string().optional().describe("Topic scope for edge lookup."),
+  limit: z.number().optional().describe("Maximum edges to return.")
+});
+var flagContradictionArgs = z.object({
+  beliefA: z.string().describe("First belief in tension."),
+  beliefB: z.string().describe("Second belief in tension."),
+  topicId: z.string().optional().describe("Topic scope for the contradiction."),
+  description: z.string().optional().describe("Human-readable contradiction."),
+  severity: z.enum(["critical", "high", "medium", "low"]).optional().describe("Contradiction severity."),
+  defeatType: z.string().optional().describe("Defeat type annotation."),
+  supportingInsightIds: z.array(z.string()).optional().describe("Evidence supporting the primary belief."),
+  contradictingInsightIds: z.array(z.string()).optional().describe("Evidence or beliefs contradicting the primary belief.")
+});
+var discoverEntityConnectionsArgs = lineageAliasArgs.extend({
+  nodeId: z.string().describe("Epistemic node ID to find entity connections for."),
+  topicId: z.string().optional().describe("Topic scope override."),
+  minScore: z.number().optional().describe("Minimum match score."),
+  limit: z.number().optional().describe("Maximum candidates to return.")
+});
 var contradictionSeverity = (value) => {
   switch (value) {
     case "critical":
@@ -20307,7 +20550,8 @@ var graphContracts = [
       functionName: "getLineage",
       kind: "query",
       inputProjection: lineageInput
-    }
+    },
+    args: traverseGraphArgs
   }),
   surfaceContract({
     name: "get_graph_neighborhood",
@@ -20323,7 +20567,8 @@ var graphContracts = [
       functionName: "getByTopic",
       kind: "query",
       inputProjection: topicEdgesInput
-    }
+    },
+    args: graphNeighborhoodArgs
   }),
   surfaceContract({
     name: "get_graph_structure_analysis",
@@ -20372,7 +20617,8 @@ var graphContracts = [
       functionName: "create",
       kind: "mutation",
       inputProjection: flagContradictionInput
-    }
+    },
+    args: flagContradictionArgs
   }),
   surfaceContract({
     name: "detect_confirmation_bias",
@@ -20463,7 +20709,8 @@ var graphContracts = [
       functionName: "getLineage",
       kind: "query",
       inputProjection: lineageInput
-    }
+    },
+    args: discoverEntityConnectionsArgs
   }),
   surfaceContract({
     name: "trigger_belief_review",
@@ -20494,7 +20741,8 @@ var graphContracts = [
       functionName: "getLineage",
       kind: "query",
       inputProjection: lineageInput
-    }
+    },
+    args: lineageArgs
   })
 ];
 
@@ -20546,8 +20794,16 @@ var contractsContracts = [
     }
   })
 ];
-
-// ../contracts/src/function-registry/judgments.ts
+var auditTrailArgs = z.object({
+  nodeId: z.string().describe("The node to audit."),
+  id: z.string().optional().describe("Node ID alias."),
+  limit: z.number().optional().describe("Maximum entries to return."),
+  depth: z.number().optional().describe("Traversal depth alias."),
+  maxDepth: z.number().optional().describe("Maximum lineage depth."),
+  mode: z.string().optional().describe("Traversal mode."),
+  minLayer: z.string().optional().describe("Minimum epistemic layer."),
+  maxLayer: z.string().optional().describe("Maximum epistemic layer.")
+});
 var judgmentsContracts = [
   surfaceContract({
     name: "record_judgment",
@@ -20602,7 +20858,8 @@ var judgmentsContracts = [
         minLayer: input.minLayer,
         maxLayer: input.maxLayer
       })
-    }
+    },
+    args: auditTrailArgs
   })
 ];
 
@@ -20667,412 +20924,1721 @@ var coordinationContracts = [
     sdkMethod: "listActiveSessions",
     summary: "List active agent sessions.",
     convex: {
-      module: "coordination",
-      functionName: "listActiveSessions",
-      kind: "query"
+      module: "coordination",
+      functionName: "listActiveSessions",
+      kind: "query"
+    }
+  }),
+  surfaceContract({
+    name: "send_agent_message",
+    kind: "mutation",
+    domain: "coordination",
+    surfaceClass: "platform_internal",
+    path: "/coordination/messages/send",
+    sdkNamespace: "coordination",
+    sdkMethod: "sendAgentMessage",
+    summary: "Send a directed agent coordination message.",
+    convex: {
+      module: "coordination",
+      functionName: "sendMessage",
+      kind: "mutation",
+      injectSessionId: "fromSessionId",
+      inputProjection: (input) => ({
+        ...input,
+        messageType: typeof input.messageType === "string" ? input.messageType : "note"
+      })
+    }
+  }),
+  surfaceContract({
+    name: "broadcast_message",
+    kind: "mutation",
+    domain: "coordination",
+    surfaceClass: "platform_internal",
+    path: "/coordination/messages/broadcast",
+    sdkNamespace: "coordination",
+    sdkMethod: "broadcastMessage",
+    summary: "Broadcast an agent coordination message.",
+    convex: {
+      module: "coordination",
+      functionName: "sendMessage",
+      kind: "mutation",
+      injectSessionId: "fromSessionId",
+      broadcastToAll: true,
+      inputProjection: (input) => ({
+        ...input,
+        messageType: typeof input.messageType === "string" ? input.messageType : "note"
+      })
+    }
+  }),
+  surfaceContract({
+    name: "get_agent_inbox",
+    kind: "query",
+    domain: "coordination",
+    surfaceClass: "platform_internal",
+    path: "/coordination/messages/inbox",
+    sdkNamespace: "coordination",
+    sdkMethod: "getAgentInbox",
+    summary: "Read an agent session inbox.",
+    convex: {
+      module: "coordination",
+      functionName: "getInbox",
+      kind: "query",
+      injectSessionId: "sessionId",
+      inputProjection: (input) => compactRecord4({
+        limit: input.limit
+      })
+    }
+  }),
+  surfaceContract({
+    name: "claim_files",
+    kind: "mutation",
+    domain: "coordination",
+    surfaceClass: "platform_internal",
+    path: "/coordination/file-claims",
+    sdkNamespace: "coordination",
+    sdkMethod: "claimFiles",
+    summary: "Claim files for advisory agent coordination.",
+    convex: {
+      module: "coordination",
+      functionName: "claimFiles",
+      kind: "mutation",
+      injectSessionId: "sessionId",
+      inputProjection: (input) => ({
+        touchedFiles: stringArray(input.touchedFiles) ?? stringArray(input.files) ?? stringArray(input.paths) ?? []
+      })
+    }
+  }),
+  surfaceContract({
+    name: "generate_session_handoff",
+    kind: "query",
+    domain: "bootstrap",
+    surfaceClass: "platform_internal",
+    path: "/bootstrap/session-handoff",
+    sdkNamespace: "bootstrap",
+    sdkMethod: "generateSessionHandoff",
+    summary: "Generate a session handoff package.",
+    convex: {
+      module: "worktrees",
+      functionName: "get",
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        worktreeId: input.worktreeId ?? input.id
+      })
+    }
+  })
+];
+var pipelineSnapshotArgs = z.object({
+  topicId: z.string().describe("Topic scope ID."),
+  status: z.string().optional().describe("Worktree status filter."),
+  lane: z.string().optional().describe("Campaign lane filter."),
+  campaign: z.number().optional().describe("Campaign number filter."),
+  limit: z.number().optional().describe("Maximum worktrees to inspect.")
+});
+var pipelineContracts = [
+  surfaceContract({
+    name: "pipeline_snapshot",
+    kind: "query",
+    domain: "worktrees",
+    surfaceClass: "platform_internal",
+    path: "/worktrees/pipeline-snapshot",
+    sdkNamespace: "worktrees",
+    sdkMethod: "pipelineSnapshot",
+    summary: "Summarize worktree pipeline state for a topic.",
+    convex: {
+      module: "worktrees",
+      functionName: "listAll",
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        status: input.status,
+        lane: input.lane,
+        campaign: input.campaign,
+        limit: input.limit
+      })
+    },
+    args: pipelineSnapshotArgs
+  }),
+  surfaceContract({
+    name: "seed_belief_lattice",
+    kind: "mutation",
+    domain: "scope",
+    surfaceClass: "platform_internal",
+    path: "/scope/belief-lattice/seed",
+    sdkNamespace: "context",
+    sdkMethod: "seedBeliefLattice",
+    summary: "Seed baseline belief lattice coverage for a topic.",
+    convex: {
+      module: "contextCompiler",
+      functionName: "seedBeliefLattice",
+      kind: "mutation"
+    }
+  }),
+  surfaceContract({
+    name: "get_lattice_coverage",
+    kind: "query",
+    domain: "scope",
+    surfaceClass: "platform_internal",
+    path: "/scope/belief-lattice/coverage",
+    sdkNamespace: "context",
+    sdkMethod: "getLatticeCoverage",
+    summary: "Read belief lattice coverage for a topic.",
+    convex: {
+      module: "contextCompiler",
+      functionName: "getLatticeCoverage",
+      kind: "query"
+    }
+  })
+];
+var recordScopeLearningArgs = z.object({
+  topicId: z.string().optional().describe("Topic scope ID"),
+  summary: z.string().describe("Atomic learning statement"),
+  title: z.string().optional().describe("Optional evidence title, such as a commit, doc, or issue."),
+  body: z.string().optional().describe(
+    "Optional rich evidence body. If omitted, body is synthesized from summary and touched paths."
+  ),
+  contentType: z.string().optional().describe("Optional evidence body format, such as markdown or text."),
+  sourceKind: z.enum(["commit", "merge", "doc", "issue", "manual"]).optional().describe("Source type for the learning event"),
+  sourceRef: z.string().optional().describe("Optional source reference, such as SHA, PR number, or URL slug."),
+  sourceUrl: z.string().optional().describe("Optional canonical source URL"),
+  touchedPaths: z.array(z.string()).optional().describe("Optional touched file paths for retrieval hints"),
+  tags: z.array(z.string()).optional().describe("Optional tags"),
+  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"),
+  text: z.string().optional().describe("Canonical learning text alias."),
+  content: z.string().optional().describe("Canonical learning content alias."),
+  kind: z.string().optional().describe("Evidence kind to store."),
+  sourceType: z.string().optional().describe("Evidence source type."),
+  externalSourceType: z.string().optional().describe("External source type alias."),
+  metadata: z.record(z.unknown()).optional().describe("Learning metadata.")
+});
+var codeContextArgs = z.object({
+  topicId: z.string().optional().describe("Topic scope."),
+  filePath: z.string().optional().describe("File path anchor."),
+  includeFailures: z.boolean().optional().describe("Whether to include failed attempts."),
+  limit: z.number().optional().describe("Maximum records to return."),
+  status: z.string().optional().describe("Evidence status filter.")
+});
+var recordAttemptArgs = z.object({
+  topicId: z.string().optional().describe("Topic scope."),
+  description: z.string().describe("Attempt description."),
+  errorMessage: z.string().optional().describe("Failure or error message."),
+  filePaths: z.array(z.string()).optional().describe("Files involved in the attempt."),
+  filePath: z.string().optional().describe("Single file path alias."),
+  linkedBeliefId: z.string().optional().describe("Linked belief ID."),
+  metadata: z.record(z.unknown()).optional().describe("Attempt metadata."),
+  rationale: z.string().optional().describe("Why this attempt should be recorded."),
+  title: z.string().optional().describe("Attempt evidence title.")
+});
+var learningInput = (input, context) => {
+  const sourceKind = input.sourceKind ?? input.externalSourceType;
+  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(
+  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: 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 = [
+  surfaceContract({
+    name: "record_scope_learning",
+    kind: "mutation",
+    domain: "scope",
+    surfaceClass: "platform_internal",
+    path: "/scope/learnings",
+    sdkNamespace: "context",
+    sdkMethod: "recordScopeLearning",
+    summary: "Record a scope-level learning to the reasoning graph.",
+    args: recordScopeLearningArgs,
+    input: recordScopeLearningArgs,
+    convex: {
+      module: "evidence",
+      functionName: "create",
+      kind: "mutation",
+      inputProjection: learningInput
     }
   }),
   surfaceContract({
-    name: "send_agent_message",
+    name: "manage_write_policy",
     kind: "mutation",
-    domain: "coordination",
-    surfaceClass: "platform_internal",
-    path: "/coordination/messages/send",
-    sdkNamespace: "coordination",
-    sdkMethod: "sendAgentMessage",
-    summary: "Send a directed agent coordination message.",
+    domain: "policy",
+    surfaceClass: "tenant_public",
+    path: "/policy/write-policy/manage",
+    sdkNamespace: "policy",
+    sdkMethod: "manageWritePolicy",
+    summary: "Manage MCP write policy rules.",
     convex: {
-      module: "coordination",
-      functionName: "sendMessage",
+      module: "evidence",
+      functionName: "create",
       kind: "mutation",
-      injectSessionId: "fromSessionId",
-      inputProjection: (input) => ({
-        ...input,
-        messageType: typeof input.messageType === "string" ? input.messageType : "note"
-      })
+      inputProjection: (input, context) => learningInput(
+        {
+          ...input,
+          summary: input.summary ?? `Write policy ${String(input.action ?? "update")}`,
+          sourceKind: "write_policy"
+        },
+        context
+      )
     }
   }),
   surfaceContract({
-    name: "broadcast_message",
-    kind: "mutation",
-    domain: "coordination",
+    name: "get_code_context",
+    kind: "query",
+    domain: "coding",
     surfaceClass: "platform_internal",
-    path: "/coordination/messages/broadcast",
-    sdkNamespace: "coordination",
-    sdkMethod: "broadcastMessage",
-    summary: "Broadcast an agent coordination message.",
+    path: "/coding/context",
+    sdkNamespace: "coding",
+    sdkMethod: "getCodeContext",
+    summary: "Read code context for graph-linked files.",
     convex: {
-      module: "coordination",
-      functionName: "sendMessage",
-      kind: "mutation",
-      injectSessionId: "fromSessionId",
-      broadcastToAll: true,
-      inputProjection: (input) => ({
-        ...input,
-        messageType: typeof input.messageType === "string" ? input.messageType : "note"
+      module: "evidence",
+      functionName: "getByTopic",
+      kind: "query",
+      inputProjection: (input) => compactRecord4({
+        topicId: input.topicId,
+        limit: input.limit,
+        status: input.status,
+        userId: input.userId
       })
-    }
+    },
+    args: codeContextArgs
   }),
   surfaceContract({
-    name: "get_agent_inbox",
+    name: "get_change_history",
     kind: "query",
-    domain: "coordination",
+    domain: "coding",
     surfaceClass: "platform_internal",
-    path: "/coordination/messages/inbox",
-    sdkNamespace: "coordination",
-    sdkMethod: "getAgentInbox",
-    summary: "Read an agent session inbox.",
+    path: "/coding/change-history",
+    sdkNamespace: "coding",
+    sdkMethod: "getChangeHistory",
+    summary: "Read recorded code change attempts.",
     convex: {
-      module: "coordination",
-      functionName: "getInbox",
+      module: "evidence",
+      functionName: "getByTopic",
       kind: "query",
-      injectSessionId: "sessionId",
       inputProjection: (input) => compactRecord4({
-        limit: input.limit
+        topicId: input.topicId,
+        limit: input.limit,
+        status: input.status,
+        userId: input.userId
       })
     }
   }),
   surfaceContract({
-    name: "claim_files",
+    name: "record_attempt",
     kind: "mutation",
-    domain: "coordination",
+    domain: "coding",
     surfaceClass: "platform_internal",
-    path: "/coordination/file-claims",
-    sdkNamespace: "coordination",
-    sdkMethod: "claimFiles",
-    summary: "Claim files for advisory agent coordination.",
+    path: "/coding/attempts",
+    sdkNamespace: "coding",
+    sdkMethod: "recordAttempt",
+    summary: "Record a code attempt for failure learning.",
     convex: {
-      module: "coordination",
-      functionName: "claimFiles",
+      module: "evidence",
+      functionName: "create",
       kind: "mutation",
-      injectSessionId: "sessionId",
-      inputProjection: (input) => ({
-        touchedFiles: stringArray(input.touchedFiles) ?? stringArray(input.files) ?? stringArray(input.paths) ?? []
-      })
-    }
+      inputProjection: attemptInput
+    },
+    args: recordAttemptArgs
   }),
   surfaceContract({
-    name: "generate_session_handoff",
+    name: "get_failure_log",
     kind: "query",
-    domain: "bootstrap",
+    domain: "coding",
     surfaceClass: "platform_internal",
-    path: "/bootstrap/session-handoff",
-    sdkNamespace: "bootstrap",
-    sdkMethod: "generateSessionHandoff",
-    summary: "Generate a session handoff package.",
+    path: "/coding/failure-log",
+    sdkNamespace: "coding",
+    sdkMethod: "getFailureLog",
+    summary: "Read code failure log entries.",
     convex: {
-      module: "worktrees",
-      functionName: "get",
+      module: "evidence",
+      functionName: "getByTopic",
       kind: "query",
       inputProjection: (input) => compactRecord4({
-        worktreeId: input.worktreeId ?? input.id
+        topicId: input.topicId ?? input.query,
+        limit: input.limit,
+        status: input.status,
+        userId: input.userId
+      })
+    }
+  })
+];
+
+// ../contracts/src/function-registry/legacy.ts
+var legacyContracts = [
+  surfaceContract({
+    name: "discover",
+    kind: "query",
+    domain: "context",
+    surfaceClass: "legacy_compat",
+    replacedBy: "compile_context",
+    path: "/context/discover",
+    sdkNamespace: "context",
+    sdkMethod: "discover",
+    summary: "Discover relevant topic context.",
+    convex: {
+      module: "contextCompiler",
+      functionName: "compile",
+      kind: "query",
+      inputProjection: (input) => ({
+        ...input,
+        query: input.query ?? input.prompt ?? input.topicHint ?? "discover"
       })
     }
   })
 ];
 
-// ../contracts/src/function-registry/pipeline.ts
-var pipelineContracts = [
-  surfaceContract({
-    name: "pipeline_snapshot",
-    kind: "query",
-    domain: "worktrees",
-    surfaceClass: "platform_internal",
-    path: "/worktrees/pipeline-snapshot",
-    sdkNamespace: "worktrees",
-    sdkMethod: "pipelineSnapshot",
-    summary: "Summarize worktree pipeline state for a topic.",
-    convex: {
-      module: "worktrees",
-      functionName: "listAll",
-      kind: "query",
-      inputProjection: (input) => compactRecord4({
-        status: input.status,
-        lane: input.lane,
-        campaign: input.campaign,
-        limit: input.limit
-      })
+// ../contracts/src/function-registry/index.ts
+var ALL_FUNCTION_CONTRACTS = [
+  ...contextContracts,
+  ...identityContracts,
+  ...beliefsContracts,
+  ...evidenceContracts,
+  ...questionsContracts,
+  ...topicsContracts,
+  ...lensesContracts,
+  ...ontologiesContracts,
+  ...worktreesContracts,
+  ...tasksContracts,
+  ...edgesContracts,
+  ...graphContracts,
+  ...contractsContracts,
+  ...judgmentsContracts,
+  ...coordinationContracts,
+  ...pipelineContracts,
+  ...codingContracts,
+  ...legacyContracts
+];
+assertSurfaceCoverage(ALL_FUNCTION_CONTRACTS);
+var FUNCTION_SURFACE_CONTRACTS = ALL_FUNCTION_CONTRACTS;
+new Map(
+  ALL_FUNCTION_CONTRACTS.map((contract) => [contract.name, contract])
+);
+
+// ../contracts/src/tenant-bootstrap-seed.contract.ts
+function isCopyableSeedRequirement(entry) {
+  return (entry.copyMode === "template_global" || entry.copyMode === "template_tenant_rewrite" || entry.copyMode === "template_reference_remap") && Boolean(entry.scope) && Array.isArray(entry.uniqueKey) && entry.uniqueKey.length > 0;
+}
+var TENANT_BOOTSTRAP_TABLE_REQUIREMENTS = [
+  {
+    component: "kernel",
+    table: "agentMessages",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Agent coordination messages are session data, not template data."
+  },
+  {
+    component: "kernel",
+    table: "agentSessions",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Agent coordination sessions are created by active clients."
+  },
+  {
+    component: "kernel",
+    table: "autofixJobs",
+    prepopulation: "runtime_queue",
+    copyMode: "none",
+    description: "Autofix work items are runtime queue rows."
+  },
+  {
+    component: "kernel",
+    table: "backgroundJobRuns",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Background job executions are runtime logs."
+  },
+  {
+    component: "kernel",
+    table: "backgroundJobSettings",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["jobKey"],
+    description: "Default job enablement settings must come from the K template."
+  },
+  {
+    component: "kernel",
+    table: "beliefConfidence",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Belief confidence rows are created with tenant graph facts."
+  },
+  {
+    component: "kernel",
+    table: "beliefEvidenceLinks",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Belief-to-evidence links are tenant graph data."
+  },
+  {
+    component: "kernel",
+    table: "beliefHistory",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Belief history is append-only tenant graph data."
+  },
+  {
+    component: "kernel",
+    table: "beliefScenarios",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Scenario rows are tenant-authored reasoning data."
+  },
+  {
+    component: "kernel",
+    table: "beliefVotes",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Decision belief votes are tenant-authored data."
+  },
+  {
+    component: "kernel",
+    table: "calibrationScores",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Calibration scores are computed from tenant outcomes."
+  },
+  {
+    component: "kernel",
+    table: "contractEvaluations",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Contract evaluation rows are runtime computation logs."
+  },
+  {
+    component: "kernel",
+    table: "contradictions",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Contradictions are tenant graph facts."
+  },
+  {
+    component: "kernel",
+    table: "crossProjectConnections",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Cross-topic connections are tenant graph facts."
+  },
+  {
+    component: "kernel",
+    table: "decisionComputedSummaries",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Decision summaries are derived tenant outputs."
+  },
+  {
+    component: "kernel",
+    table: "decisionEvents",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Decision events are lifecycle data."
+  },
+  {
+    component: "kernel",
+    table: "decisionParticipants",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Decision participants are tenant-selected actors."
+  },
+  {
+    component: "kernel",
+    table: "decisionRiskLedger",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Decision risk rows are tenant decision data."
+  },
+  {
+    component: "kernel",
+    table: "decisionSnapshots",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Decision snapshots are derived from tenant state."
+  },
+  {
+    component: "kernel",
+    table: "deliberationContributions",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Deliberation contributions are tenant-authored data."
+  },
+  {
+    component: "kernel",
+    table: "deliberationSessions",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Deliberation sessions are created by tenant workflows."
+  },
+  {
+    component: "kernel",
+    table: "epistemicAudit",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Epistemic audit rows are append-only runtime audit data."
+  },
+  {
+    component: "kernel",
+    table: "epistemicContracts",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Epistemic contracts are tenant-authored governance data."
+  },
+  {
+    component: "kernel",
+    table: "epistemicEdges",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Edges are tenant reasoning graph data."
+  },
+  {
+    component: "kernel",
+    table: "epistemicNodeEmbeddings",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Embeddings are derived from tenant graph nodes."
+  },
+  {
+    component: "kernel",
+    table: "epistemicNodes",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Nodes are tenant reasoning graph data."
+  },
+  {
+    component: "kernel",
+    table: "graphAnalysisCache",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Graph analysis cache rows are derived from tenant graph state."
+  },
+  {
+    component: "kernel",
+    table: "graphAnalysisResults",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Graph analysis result rows are derived tenant outputs."
+  },
+  {
+    component: "kernel",
+    table: "graphSuggestions",
+    prepopulation: "runtime_derived",
+    copyMode: "none",
+    description: "Graph suggestions are derived recommendations."
+  },
+  {
+    component: "kernel",
+    table: "harnessReplays",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Harness replay rows are runtime verification logs."
+  },
+  {
+    component: "kernel",
+    table: "harnessRuns",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Harness run rows are runtime verification logs."
+  },
+  {
+    component: "kernel",
+    table: "idempotencyTokens",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Idempotency tokens are request-scoped runtime guards."
+  },
+  {
+    component: "kernel",
+    table: "lenses",
+    prepopulation: "optional_template",
+    copyMode: "none",
+    description: "Reusable lens templates may live in K templates, but workspace-specific copies are not required for core SDK boot."
+  },
+  {
+    component: "kernel",
+    table: "lensTopicBindings",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Lens bindings attach runtime topics to runtime/workspace lenses."
+  },
+  {
+    component: "kernel",
+    table: "neo4jSyncQueue",
+    prepopulation: "runtime_queue",
+    copyMode: "none",
+    description: "Neo4j sync queue rows are runtime work items."
+  },
+  {
+    component: "kernel",
+    table: "ontologyDefinitions",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["ontologyKey"],
+    description: "Platform ontology definitions power taxonomy reads and effective ontology resolution."
+  },
+  {
+    component: "kernel",
+    table: "ontologyVersions",
+    prepopulation: "required_template",
+    copyMode: "template_reference_remap",
+    scope: "global",
+    uniqueKey: ["ontologyKey", "version"],
+    dependsOn: ["ontologyDefinitions"],
+    description: "Ontology versions must be copied with ontologyDefinition ID remapping."
+  },
+  {
+    component: "kernel",
+    table: "platformAgentRunPolicyDecisions",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Agent-run policy decisions are audit logs."
+  },
+  {
+    component: "kernel",
+    table: "platformAgentRunPromptResolutions",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Agent-run prompt resolution rows are runtime logs."
+  },
+  {
+    component: "kernel",
+    table: "platformAgentRuns",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Agent runs are runtime execution records."
+  },
+  {
+    component: "kernel",
+    table: "platformAgentRunToolCalls",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Agent-run tool calls are runtime execution records."
+  },
+  {
+    component: "kernel",
+    table: "platformHarnessShadowAudit",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Harness shadow audit rows are runtime audit records."
+  },
+  {
+    component: "kernel",
+    table: "publicationRules",
+    prepopulation: "required_template",
+    copyMode: "template_tenant_rewrite",
+    scope: "tenant",
+    uniqueKey: ["tenantId", "workspaceId", "name"],
+    description: "Default publication policy rules are rewritten into each tenant."
+  },
+  {
+    component: "kernel",
+    table: "questionEvidenceLinks",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Question-to-evidence links are tenant graph data."
+  },
+  {
+    component: "kernel",
+    table: "researchJobs",
+    prepopulation: "runtime_queue",
+    copyMode: "none",
+    description: "Research job rows are runtime queue items."
+  },
+  {
+    component: "kernel",
+    table: "schemaEnumConfig",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["category", "value"],
+    description: "Runtime-extensible enum defaults required by SDK graph APIs."
+  },
+  {
+    component: "kernel",
+    table: "stakeholderGroups",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Stakeholder groups are tenant decision data."
+  },
+  {
+    component: "kernel",
+    table: "systemLogs",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "System logs are runtime telemetry."
+  },
+  {
+    component: "kernel",
+    table: "tasks",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Tasks are tenant-authored work items."
+  },
+  {
+    component: "kernel",
+    table: "topics",
+    prepopulation: "runtime_bootstrap",
+    copyMode: "none",
+    description: "Default topics are created by tenant provisioning, not copied from templates."
+  },
+  {
+    component: "kernel",
+    table: "workflowDefinitions",
+    prepopulation: "optional_template",
+    copyMode: "none",
+    description: "Table-driven workflow definitions can be template data after the workflow engine leaves legacy mode."
+  },
+  {
+    component: "kernel",
+    table: "workflowPullRequests",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Workflow pull requests are tenant workflow data."
+  },
+  {
+    component: "kernel",
+    table: "workflowStages",
+    prepopulation: "optional_template",
+    copyMode: "none",
+    dependsOn: ["workflowDefinitions"],
+    description: "Workflow stages can be template data after workflowDefinitions are enabled for bootstrap copying."
+  },
+  {
+    component: "kernel",
+    table: "worktreeBeliefCluster",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Worktree cluster rows link runtime worktrees to runtime beliefs."
+  },
+  {
+    component: "kernel",
+    table: "worktrees",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Worktrees are tenant/runtime planning data."
+  },
+  {
+    component: "identity",
+    table: "agents",
+    prepopulation: "runtime_bootstrap",
+    copyMode: "none",
+    description: "Service agents are provisioned per tenant or service, not copied."
+  },
+  {
+    component: "identity",
+    table: "mcpWritePolicy",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["topicId", "role", "toolCategory"],
+    description: "Global write policy defaults govern service and interactive MCP writes."
+  },
+  {
+    component: "identity",
+    table: "modelCallLogs",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Model call logs are runtime telemetry."
+  },
+  {
+    component: "identity",
+    table: "modelFunctionSlots",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["slot"],
+    description: "Function-to-model slots are required by model runtime resolution."
+  },
+  {
+    component: "identity",
+    table: "modelRegistry",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["key"],
+    description: "Model catalog defaults are required by model runtime clients."
+  },
+  {
+    component: "identity",
+    table: "modelSlotConfigs",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["slot"],
+    description: "Slot-level defaults are required before tenant overrides exist."
+  },
+  {
+    component: "identity",
+    table: "platformAudienceGrants",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Audience grants are principal/group-specific access rows."
+  },
+  {
+    component: "identity",
+    table: "platformAudiences",
+    prepopulation: "required_template",
+    copyMode: "template_tenant_rewrite",
+    scope: "tenant",
+    uniqueKey: ["tenantId", "workspaceId", "audienceKey"],
+    description: "Default tenant audience taxonomy rows are rewritten into each tenant."
+  },
+  {
+    component: "identity",
+    table: "platformPolicyDecisionLogs",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Policy decisions are runtime audit logs."
+  },
+  {
+    component: "identity",
+    table: "projectGrants",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Project/topic grants are principal or group-specific access rows."
+  },
+  {
+    component: "identity",
+    table: "reasoningPermissions",
+    prepopulation: "runtime_data",
+    copyMode: "none",
+    description: "Reasoning permissions are principal-specific policy rows."
+  },
+  {
+    component: "identity",
+    table: "tenantApiKeys",
+    prepopulation: "runtime_secret",
+    copyMode: "none",
+    description: "API keys are tenant credentials and must never be copied."
+  },
+  {
+    component: "identity",
+    table: "tenantConfig",
+    prepopulation: "required_template",
+    copyMode: "template_tenant_rewrite",
+    scope: "tenant",
+    uniqueKey: ["tenantId"],
+    description: "Tenant-local config defaults are rewritten during bootstrap."
+  },
+  {
+    component: "identity",
+    table: "tenantIntegrations",
+    prepopulation: "required_template",
+    copyMode: "template_tenant_rewrite",
+    scope: "tenant",
+    uniqueKey: ["tenantId", "integrationKey"],
+    description: "Non-secret integration descriptors are rewritten into each tenant."
+  },
+  {
+    component: "identity",
+    table: "tenantModelSlotBindings",
+    prepopulation: "runtime_secret",
+    copyMode: "none",
+    description: "Tenant model slot bindings reference provider secrets and are runtime-only."
+  },
+  {
+    component: "identity",
+    table: "tenantPolicies",
+    prepopulation: "required_template",
+    copyMode: "template_tenant_rewrite",
+    scope: "tenant",
+    uniqueKey: ["tenantId", "workspaceId", "roleName"],
+    description: "Default tenant policy roles are rewritten during bootstrap."
+  },
+  {
+    component: "identity",
+    table: "tenantProviderSecrets",
+    prepopulation: "runtime_secret",
+    copyMode: "none",
+    description: "Provider secrets are credentials and must never be copied."
+  },
+  {
+    component: "identity",
+    table: "tenantProxyGatewayUsage",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Proxy gateway usage rows are runtime telemetry."
+  },
+  {
+    component: "identity",
+    table: "tenantProxyTokenMints",
+    prepopulation: "runtime_secret",
+    copyMode: "none",
+    description: "Proxy token mints are ephemeral secret-bearing runtime rows."
+  },
+  {
+    component: "identity",
+    table: "tenantSandboxAuditEvents",
+    prepopulation: "runtime_log",
+    copyMode: "none",
+    description: "Sandbox audit rows are runtime security logs."
+  },
+  {
+    component: "identity",
+    table: "tenantSecrets",
+    prepopulation: "runtime_secret",
+    copyMode: "none",
+    description: "Tenant secrets are credentials and must never be copied."
+  },
+  {
+    component: "identity",
+    table: "toolAcls",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["role", "toolName"],
+    description: "Default role-to-tool grants are required for SDK/MCP tool access."
+  },
+  {
+    component: "identity",
+    table: "toolRegistry",
+    prepopulation: "required_template",
+    copyMode: "template_global",
+    scope: "global",
+    uniqueKey: ["toolName"],
+    description: "Core tool catalog rows are required before pack or tenant tools exist."
+  },
+  {
+    component: "identity",
+    table: "users",
+    prepopulation: "runtime_bootstrap",
+    copyMode: "none",
+    description: "Users are created from Clerk/MC principal resolution, not copied."
+  }
+];
+TENANT_BOOTSTRAP_TABLE_REQUIREMENTS.filter(
+  isCopyableSeedRequirement
+);
+TENANT_BOOTSTRAP_TABLE_REQUIREMENTS.filter(
+  (entry) => !isCopyableSeedRequirement(entry)
+).map((entry) => entry.table);
+
+// src/execution.ts
+var SCOPE_ALIAS_GROUPS = [];
+function createToolExecutionEnvelope(args) {
+  return {
+    toolName: args.toolName,
+    params: args.params,
+    contract: args.contract,
+    transport: {
+      kind: args.transportKind,
+      surface: args.transportKind === "chat" ? "chat" : "mcp",
+      normalizedAt: "handler_boundary"
+    },
+    auth: {
+      mode: args.authMode
+    },
+    policy: {
+      requiredScopes: args.requiredScopes,
+      enforcement: "gateway"
+    },
+    audit: {
+      source: "gateway_envelope",
+      structuralFields: [
+        "toolName",
+        "code",
+        "status",
+        "correlationId",
+        "policyTraceId",
+        "invariant"
+      ]
     }
-  }),
-  surfaceContract({
-    name: "seed_belief_lattice",
-    kind: "mutation",
-    domain: "scope",
-    surfaceClass: "platform_internal",
-    path: "/scope/belief-lattice/seed",
-    sdkNamespace: "context",
-    sdkMethod: "seedBeliefLattice",
-    summary: "Seed baseline belief lattice coverage for a topic.",
-    convex: {
-      module: "contextCompiler",
-      functionName: "seedBeliefLattice",
-      kind: "mutation"
+  };
+}
+function hasValue(value) {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  return true;
+}
+function normalizeToolExecutionParams(params) {
+  const normalized = { ...params };
+  for (const aliases of SCOPE_ALIAS_GROUPS) {
+    const sourceKey = aliases.find((key) => hasValue(normalized[key]));
+    if (!sourceKey) {
+      continue;
     }
-  }),
-  surfaceContract({
-    name: "get_lattice_coverage",
-    kind: "query",
-    domain: "scope",
-    surfaceClass: "platform_internal",
-    path: "/scope/belief-lattice/coverage",
-    sdkNamespace: "context",
-    sdkMethod: "getLatticeCoverage",
-    summary: "Read belief lattice coverage for a topic.",
-    convex: {
-      module: "contextCompiler",
-      functionName: "getLatticeCoverage",
-      kind: "query"
+    for (const key of aliases) {
+      if (!hasValue(normalized[key])) {
+        normalized[key] = normalized[sourceKey];
+      }
     }
-  })
-];
-var recordScopeLearningArgs = z.object({
-  topicId: z.string().optional().describe("Topic scope ID"),
-  summary: z.string().describe("Atomic learning statement"),
-  title: z.string().optional().describe("Optional evidence title, such as a commit, doc, or issue."),
-  body: z.string().optional().describe(
-    "Optional rich evidence body. If omitted, body is synthesized from summary and touched paths."
-  ),
-  contentType: z.string().optional().describe("Optional evidence body format, such as markdown or text."),
-  sourceKind: z.enum(["commit", "merge", "doc", "issue", "manual"]).optional().describe("Source type for the learning event"),
-  sourceRef: z.string().optional().describe("Optional source reference, such as SHA, PR number, or URL slug."),
-  sourceUrl: z.string().optional().describe("Optional canonical source URL"),
-  touchedPaths: z.array(z.string()).optional().describe("Optional touched file paths for retrieval hints"),
-  tags: z.array(z.string()).optional().describe("Optional tags"),
-  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) => {
-  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
-  );
+  }
+  return normalized;
+}
+function parseToolExecutionMetadata(result) {
+  const raw = result.content[0]?.text;
+  if (!raw) {
+    return { isError: Boolean(result.isError) };
+  }
+  try {
+    const payload = JSON.parse(raw);
+    return {
+      isError: Boolean(result.isError),
+      code: typeof payload.code === "string" ? payload.code : void 0,
+      status: typeof payload.status === "number" ? payload.status : void 0,
+      correlationId: typeof payload.correlationId === "string" || payload.correlationId === null ? payload.correlationId : void 0,
+      policyTraceId: typeof payload.policyTraceId === "string" || payload.policyTraceId === null ? payload.policyTraceId : void 0,
+      invariant: typeof payload.invariant === "string" || payload.invariant === null ? payload.invariant : void 0
+    };
+  } catch {
+    return { isError: Boolean(result.isError) };
+  }
+}
+async function executeToolWithEnvelope(args) {
+  await args.hooks?.onEnvelope?.(args.envelope);
+  const result = await args.execute();
+  const metadata = parseToolExecutionMetadata(result);
+  await args.hooks?.onAuditEvent?.({
+    toolName: args.envelope.toolName,
+    contractName: args.envelope.contract.name,
+    transportKind: args.envelope.transport.kind,
+    authMode: args.envelope.auth.mode,
+    requiredScopes: args.envelope.policy.requiredScopes,
+    source: args.envelope.audit.source,
+    ...metadata
+  });
+  return result;
+}
+
+// src/types.ts
+var McpHandlerError = class extends Error {
+  code;
+  status;
+  suggestion;
+  constructor(message, code = "INVALID_REQUEST", status = 400, suggestion) {
+    super(message);
+    this.name = "McpHandlerError";
+    this.code = code;
+    this.status = status;
+    this.suggestion = suggestion;
+  }
 };
-var attemptInput = (input, context) => withUserId(
-  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: 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 = [
-  surfaceContract({
-    name: "record_scope_learning",
-    kind: "mutation",
-    domain: "scope",
-    surfaceClass: "platform_internal",
-    path: "/scope/learnings",
-    sdkNamespace: "context",
-    sdkMethod: "recordScopeLearning",
-    summary: "Record a scope-level learning to the reasoning graph.",
-    args: recordScopeLearningArgs,
-    input: recordScopeLearningArgs,
-    convex: {
-      module: "evidence",
-      functionName: "create",
-      kind: "mutation",
-      inputProjection: learningInput
+
+// src/handler-factory.ts
+function isMissing(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return value.trim().length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  return false;
+}
+function readString3(params, key, options = {}) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    if (options.required) {
+      throw new McpHandlerError(`Missing required parameter: ${key}`);
     }
-  }),
-  surfaceContract({
-    name: "manage_write_policy",
-    kind: "mutation",
-    domain: "policy",
-    surfaceClass: "tenant_public",
-    path: "/policy/write-policy/manage",
-    sdkNamespace: "policy",
-    sdkMethod: "manageWritePolicy",
-    summary: "Manage MCP write policy rules.",
-    convex: {
-      module: "evidence",
-      functionName: "create",
-      kind: "mutation",
-      inputProjection: (input, context) => learningInput(
-        {
-          ...input,
-          summary: input.summary ?? `Write policy ${String(input.action ?? "update")}`,
-          sourceKind: "write_policy"
-        },
-        context
-      )
+    return;
+  }
+  if (typeof value !== "string") {
+    throw new McpHandlerError(`Expected string parameter: ${key}`);
+  }
+  const trimmed = value.trim();
+  if (!trimmed && options.required) {
+    throw new McpHandlerError(`Missing required parameter: ${key}`);
+  }
+  return trimmed || void 0;
+}
+function readNumber2(params, key, options = {}) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    if (options.required) {
+      throw new McpHandlerError(`Missing required parameter: ${key}`);
     }
-  }),
-  surfaceContract({
-    name: "get_code_context",
-    kind: "query",
-    domain: "coding",
-    surfaceClass: "platform_internal",
-    path: "/coding/context",
-    sdkNamespace: "coding",
-    sdkMethod: "getCodeContext",
-    summary: "Read code context for graph-linked files.",
-    convex: {
-      module: "evidence",
-      functionName: "getByTopic",
-      kind: "query",
-      inputProjection: (input) => compactRecord4({
-        topicId: input.topicId,
-        limit: input.limit,
-        status: input.status,
-        userId: input.userId
-      })
+    return;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new McpHandlerError(`Expected numeric parameter: ${key}`);
+  }
+  return value;
+}
+function readBoolean(params, key, options = {}) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    if (options.required) {
+      throw new McpHandlerError(`Missing required parameter: ${key}`);
     }
-  }),
-  surfaceContract({
-    name: "get_change_history",
-    kind: "query",
-    domain: "coding",
-    surfaceClass: "platform_internal",
-    path: "/coding/change-history",
-    sdkNamespace: "coding",
-    sdkMethod: "getChangeHistory",
-    summary: "Read recorded code change attempts.",
-    convex: {
-      module: "evidence",
-      functionName: "getByTopic",
-      kind: "query",
-      inputProjection: (input) => compactRecord4({
-        topicId: input.topicId,
-        limit: input.limit,
-        status: input.status,
-        userId: input.userId
-      })
+    return;
+  }
+  if (typeof value !== "boolean") {
+    throw new McpHandlerError(`Expected boolean parameter: ${key}`);
+  }
+  return value;
+}
+function readStringArray(params, key) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    return;
+  }
+  if (!Array.isArray(value)) {
+    throw new McpHandlerError(`Expected array parameter: ${key}`);
+  }
+  const values = value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0);
+  return values.length > 0 ? values : void 0;
+}
+function readTopicId4(params, options = {}) {
+  const value = params.topicId;
+  if (value === void 0 || value === null) {
+    if (options.required) {
+      throw new McpHandlerError("Missing required parameter: topicId");
     }
-  }),
-  surfaceContract({
-    name: "record_attempt",
-    kind: "mutation",
-    domain: "coding",
-    surfaceClass: "platform_internal",
-    path: "/coding/attempts",
-    sdkNamespace: "coding",
-    sdkMethod: "recordAttempt",
-    summary: "Record a code attempt for failure learning.",
-    convex: {
-      module: "evidence",
-      functionName: "create",
-      kind: "mutation",
-      inputProjection: attemptInput
+    return;
+  }
+  if (typeof value !== "string") {
+    throw new McpHandlerError("Expected string parameter: topicId");
+  }
+  const trimmed = value.trim();
+  if (!trimmed && options.required) {
+    throw new McpHandlerError("Missing required parameter: topicId");
+  }
+  return trimmed || void 0;
+}
+function toMcpResult(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload) }]
+  };
+}
+function toMcpError(error) {
+  if (error instanceof McpHandlerError) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            code: error.code,
+            status: error.status,
+            message: error.message,
+            suggestion: error.suggestion ?? null
+          })
+        }
+      ]
+    };
+  }
+  if (error instanceof LucernApiError) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            code: error.code,
+            status: error.status,
+            message: error.message,
+            invariant: error.invariant ?? null,
+            suggestion: error.suggestion ?? null,
+            correlationId: error.correlationId,
+            policyTraceId: error.policyTraceId
+          })
+        }
+      ]
+    };
+  }
+  const message = error instanceof Error ? error.message : "Tool execution failed.";
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          code: "INTERNAL_ERROR",
+          status: 500,
+          message
+        })
+      }
+    ]
+  };
+}
+function createNotImplementedHandler(name) {
+  return async () => toMcpError(
+    new McpHandlerError(
+      `Tool not implemented yet: ${name}`,
+      "NOT_IMPLEMENTED",
+      501
+    )
+  );
+}
+function validateRequired(params, contract) {
+  for (const key of contract.required) {
+    if (isMissing(params[key])) {
+      throw new McpHandlerError(`Missing required parameter: ${key}`);
     }
-  }),
-  surfaceContract({
-    name: "get_failure_log",
-    kind: "query",
-    domain: "coding",
-    surfaceClass: "platform_internal",
-    path: "/coding/failure-log",
-    sdkNamespace: "coding",
-    sdkMethod: "getFailureLog",
-    summary: "Read code failure log entries.",
-    convex: {
-      module: "evidence",
-      functionName: "getByTopic",
-      kind: "query",
-      inputProjection: (input) => compactRecord4({
-        topicId: input.topicId ?? input.query,
-        limit: input.limit,
-        status: input.status,
-        userId: input.userId
-      })
+  }
+}
+function contractToHandler(contract, executor) {
+  return async (params) => {
+    try {
+      validateRequired(params, contract);
+      const payload = await executor(params);
+      return toMcpResult(payload);
+    } catch (error) {
+      return toMcpError(error);
     }
-  })
-];
+  };
+}
 
-// ../contracts/src/function-registry/legacy.ts
-var legacyContracts = [
-  surfaceContract({
-    name: "discover",
-    kind: "query",
-    domain: "context",
-    surfaceClass: "legacy_compat",
-    replacedBy: "compile_context",
-    path: "/context/discover",
-    sdkNamespace: "context",
-    sdkMethod: "discover",
-    summary: "Discover relevant topic context.",
-    convex: {
-      module: "contextCompiler",
-      functionName: "compile",
-      kind: "query",
-      inputProjection: (input) => ({
-        ...input,
-        query: input.query ?? input.prompt ?? input.topicHint ?? "discover"
-      })
+// src/handlers/beliefs.ts
+var AMBIGUOUS_SCALAR_SUGGESTION = "Use opinion tuple (b, d, u, a) or an @lucern/sdk opinionFromBaseRate/opinionFromDogmatic/opinionFromProjected helper.";
+function readOpinionTuple(params) {
+  const belief = readNumber2(params, "belief");
+  const disbelief = readNumber2(params, "disbelief");
+  const uncertainty = readNumber2(params, "uncertainty");
+  const baseRate = readNumber2(params, "baseRate");
+  const tupleValues = [belief, disbelief, uncertainty, baseRate];
+  const providedCount = tupleValues.filter(
+    (value) => value !== void 0
+  ).length;
+  if (providedCount === 0) {
+    if (readNumber2(params, "confidence") !== void 0) {
+      throw new McpHandlerError(
+        "Scalar confidence input is ambiguous without an explicit subjective-logic interpretation.",
+        "AMBIGUOUS_SCALAR",
+        400,
+        AMBIGUOUS_SCALAR_SUGGESTION
+      );
+    }
+    throw new McpHandlerError(
+      "Missing required opinion tuple: belief, disbelief, uncertainty, and baseRate are required.",
+      "INVALID_REQUEST",
+      400
+    );
+  }
+  if (providedCount !== tupleValues.length) {
+    throw new McpHandlerError(
+      "Incomplete opinion tuple: belief, disbelief, uncertainty, and baseRate must all be provided together.",
+      "INVALID_REQUEST",
+      400
+    );
+  }
+  return {
+    b: belief,
+    d: disbelief,
+    u: uncertainty,
+    a: baseRate
+  };
+}
+function createBeliefHandlers(context) {
+  const beliefs = createBeliefsClient(context.sdkConfig);
+  const graph = createGraphClient(context.sdkConfig);
+  return {
+    create_belief: contractToHandler(
+      MCP_TOOL_CONTRACTS.create_belief,
+      async (params) => {
+        const result = await beliefs.createBelief({
+          canonicalText: readString3(params, "canonicalText", {
+            required: true
+          }),
+          topicId: readTopicId4(params, { required: true }),
+          layer: readString3(params, "layer"),
+          domain: readString3(params, "domain"),
+          subtype: readString3(params, "nodeType"),
+          baseRate: readNumber2(params, "baseRate", { required: true })
+        });
+        return {
+          nodeId: result.data.nodeId,
+          globalId: result.data.globalId,
+          status: result.data.status ?? "unscored"
+        };
+      }
+    ),
+    refine_belief: contractToHandler(
+      MCP_TOOL_CONTRACTS.refine_belief,
+      async (params) => {
+        const nodeId = readString3(params, "nodeId", { required: true });
+        const canonicalText = readString3(params, "canonicalText", {
+          required: true
+        });
+        const rationale = readString3(params, "rationale");
+        const result = await beliefs.refineBelief(nodeId, {
+          canonicalText,
+          rationale
+        });
+        return {
+          nodeId: result.data.nodeId ?? nodeId,
+          canonicalText: result.data.canonicalText ?? canonicalText,
+          updatedAt: result.data.updatedAt ?? Date.now()
+        };
+      }
+    ),
+    modulate_confidence: contractToHandler(
+      MCP_TOOL_CONTRACTS.modulate_confidence,
+      async (params) => {
+        const nodeId = readString3(params, "nodeId", { required: true });
+        const opinion = readOpinionTuple(params);
+        const result = await beliefs.modulateConfidence(nodeId, {
+          opinion,
+          trigger: readString3(params, "trigger", { required: true }),
+          rationale: readString3(params, "rationale", { required: true }),
+          triggeringEvidenceId: readString3(params, "triggeringEvidenceId"),
+          triggeringQuestionId: readString3(params, "triggeringQuestionId"),
+          triggeringAnswerId: readString3(params, "triggeringAnswerId"),
+          triggeringContradictionId: readString3(
+            params,
+            "triggeringContradictionId"
+          ),
+          triggeringWorktreeId: readString3(params, "triggeringWorktreeId")
+        });
+        return {
+          nodeId,
+          newConfidence: result.data.newConfidence ?? result.data.confidence ?? opinion.b + opinion.a * opinion.u,
+          previousConfidence: result.data.previousConfidence ?? null,
+          trigger: readString3(params, "trigger", { required: true })
+        };
+      }
+    ),
+    fork_belief: contractToHandler(
+      MCP_TOOL_CONTRACTS.fork_belief,
+      async (params) => {
+        const nodeId = readString3(params, "nodeId", { required: true });
+        const forkReason = readString3(params, "forkReason", {
+          required: true
+        });
+        const result = await beliefs.forkBelief(nodeId, {
+          newFormulation: readString3(params, "newFormulation", {
+            required: true
+          }),
+          forkReason
+        });
+        return {
+          nodeId: result.data.nodeId,
+          parentNodeId: result.data.parentNodeId ?? nodeId,
+          forkReason: result.data.forkReason ?? forkReason
+        };
+      }
+    ),
+    archive_belief: contractToHandler(
+      MCP_TOOL_CONTRACTS.archive_belief,
+      async (params) => {
+        const nodeId = readString3(params, "nodeId", { required: true });
+        const rationale = readString3(params, "rationale");
+        const result = await graph.updateNode({
+          nodeId,
+          status: "archived",
+          metadata: rationale ? {
+            archiveRationale: rationale
+          } : void 0
+        });
+        return {
+          nodeId: result.data.nodeId ?? nodeId,
+          status: "archived"
+        };
+      }
+    )
+  };
+}
+var PUBLIC_TOPIC_PREFIX = "top_";
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function encodePublicTopicId(topicId) {
+  if (!isNonEmptyString(topicId)) {
+    return void 0;
+  }
+  return topicId.startsWith(PUBLIC_TOPIC_PREFIX) ? topicId : `${PUBLIC_TOPIC_PREFIX}${topicId}`;
+}
+function readExistingContext(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return {};
     }
-  })
-];
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeLocalLucernContext(context, cwd = process.cwd()) {
+  try {
+    const filePath = path.join(cwd, ".lucern.json");
+    const previous = readExistingContext(filePath);
+    const topicId = encodePublicTopicId(context.topicId ?? previous.topicId);
+    const topicName = context.topicName ?? previous.topicName;
+    const normalized = {
+      ...previous,
+      ...context,
+      ...topicId ? { topicId, projectId: topicId } : {},
+      ...topicName ? { topicName, projectName: topicName } : {},
+      lastUpdated: context.lastUpdated ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs.writeFileSync(
+      filePath,
+      `${JSON.stringify(normalized, null, 2)}
+`,
+      "utf8"
+    );
+  } catch {
+  }
+}
 
-// ../contracts/src/function-registry/index.ts
-var ALL_FUNCTION_CONTRACTS = [
-  ...contextContracts,
-  ...identityContracts,
-  ...beliefsContracts,
-  ...evidenceContracts,
-  ...questionsContracts,
-  ...topicsContracts,
-  ...lensesContracts,
-  ...ontologiesContracts,
-  ...worktreesContracts,
-  ...tasksContracts,
-  ...edgesContracts,
-  ...graphContracts,
-  ...contractsContracts,
-  ...judgmentsContracts,
-  ...coordinationContracts,
-  ...pipelineContracts,
-  ...codingContracts,
-  ...legacyContracts
-];
-assertSurfaceCoverage(ALL_FUNCTION_CONTRACTS);
-var FUNCTION_SURFACE_CONTRACTS = ALL_FUNCTION_CONTRACTS;
-new Map(
-  ALL_FUNCTION_CONTRACTS.map((contract) => [contract.name, contract])
-);
+// src/handlers/context.ts
+function readResultString(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const candidate = value[key];
+  return typeof candidate === "string" && candidate.trim().length > 0 ? candidate.trim() : void 0;
+}
+function createContextHandlers(context) {
+  const compiler = createContextClient(context.sdkConfig);
+  return {
+    compile_context: contractToHandler(
+      MCP_TOOL_CONTRACTS.compile_context,
+      async (params) => {
+        const topicId = readTopicId4(params, { required: true });
+        const response = await compiler.compile(
+          topicId,
+          {
+            ...readString3(params, "query") ? { query: readString3(params, "query") } : {},
+            ...readNumber2(params, "budget") !== void 0 ? { budget: readNumber2(params, "budget") } : {},
+            ...readString3(params, "ranking") ? {
+              ranking: readString3(params, "ranking")
+            } : {},
+            ...readNumber2(params, "limit") !== void 0 ? { limit: readNumber2(params, "limit") } : {},
+            ...readNumber2(params, "maxDepth") !== void 0 ? { maxDepth: readNumber2(params, "maxDepth") } : {},
+            ...readBoolean(params, "includeEntities") !== void 0 ? { includeEntities: readBoolean(params, "includeEntities") } : {}
+          }
+        );
+        writeLocalLucernContext({
+          topicId: readResultString(response.data, "topicId") ?? topicId,
+          topicName: readResultString(response.data, "topicName"),
+          activeWorktree: null
+        });
+        return response.data;
+      }
+    )
+  };
+}
+
+// src/handlers/contradictions.ts
+function createContradictionHandlers(context) {
+  const lucern = createLucernClient(context.sdkConfig);
+  return {
+    flag_contradiction: contractToHandler(
+      MCP_TOOL_CONTRACTS.flag_contradiction,
+      async (params) => {
+        const beliefA = readString3(params, "beliefA", { required: true });
+        const beliefB = readString3(params, "beliefB", { required: true });
+        const description = readString3(params, "description", {
+          required: true
+        });
+        const topicId = readTopicId4(params, { required: true });
+        const severity = readString3(params, "severity") ?? "medium";
+        const defeatType = readString3(params, "defeatType") ?? "rebuts";
+        const contradiction = await lucern.contradictions.flag({
+          beliefA,
+          beliefB,
+          description,
+          topicId,
+          severity,
+          defeatType
+        });
+        return {
+          contradictionId: contradiction.contradictionId,
+          status: contradiction.status,
+          beliefA: contradiction.beliefA,
+          beliefB: contradiction.beliefB
+        };
+      }
+    )
+  };
+}
+
+// src/handlers/edges.ts
+function createEdgeHandlers(context) {
+  const lucern = createLucernClient(context.sdkConfig);
+  return {
+    create_edge: contractToHandler(
+      MCP_TOOL_CONTRACTS.create_edge,
+      async (params) => {
+        const sourceId = readString3(params, "sourceId", { required: true });
+        const targetId = readString3(params, "targetId", { required: true });
+        const edgeType = readString3(params, "edgeType", { required: true });
+        const confidence = readNumber2(params, "confidence");
+        const weight = readNumber2(params, "weight");
+        const contextText = readString3(params, "context") ?? readString3(params, "reasoning");
+        const edge = await lucern.edges.create({
+          sourceId,
+          targetId,
+          edgeType,
+          confidence,
+          weight,
+          context: contextText
+        });
+        return {
+          globalId: edge.globalId ?? edge.edgeId ?? "",
+          edgeType: edge.edgeType ?? edgeType,
+          fromLayer: edge.fromLayer ?? "unknown",
+          toLayer: edge.toLayer ?? "unknown"
+        };
+      }
+    )
+  };
+}
+
+// src/handlers/evidence.ts
+function readMetadata(params) {
+  const metadata = params.metadata;
+  return metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : void 0;
+}
+function createEvidenceHandlers(context) {
+  const lucern = createLucernClient(context.sdkConfig);
+  return {
+    create_evidence: contractToHandler(
+      MCP_TOOL_CONTRACTS.create_evidence,
+      async (params) => {
+        const response = await lucern.evidence.create({
+          topicId: readTopicId4(params, { required: true }),
+          text: readString3(params, "text", { required: true }),
+          source: readString3(params, "source"),
+          targetId: readString3(params, "targetId"),
+          weight: readNumber2(params, "weight"),
+          metadata: readMetadata(params),
+          title: readString3(params, "title"),
+          content: readString3(params, "content"),
+          contentType: readString3(params, "contentType"),
+          kind: readString3(params, "kind")
+        });
+        return response.data;
+      }
+    ),
+    get_evidence: contractToHandler(
+      MCP_TOOL_CONTRACTS.get_evidence,
+      async (params) => {
+        const response = await lucern.evidence.get(
+          readString3(params, "id", { required: true })
+        );
+        return response.data;
+      }
+    ),
+    list_evidence: contractToHandler(
+      MCP_TOOL_CONTRACTS.list_evidence,
+      async (params) => {
+        const response = await lucern.evidence.list({
+          topicId: readTopicId4(params),
+          targetId: readString3(params, "targetId"),
+          limit: readNumber2(params, "limit"),
+          cursor: readString3(params, "cursor")
+        });
+        return response.data;
+      }
+    ),
+    link_evidence: contractToHandler(
+      MCP_TOOL_CONTRACTS.link_evidence,
+      async (params) => {
+        const response = await lucern.evidence.link({
+          evidenceId: readString3(params, "evidenceId", { required: true }),
+          targetId: readString3(params, "targetId", { required: true }),
+          weight: readNumber2(params, "weight"),
+          rationale: readString3(params, "rationale")
+        });
+        return response.data;
+      }
+    ),
+    search_evidence: contractToHandler(
+      MCP_TOOL_CONTRACTS.search_evidence,
+      async (params) => {
+        const response = await lucern.evidence.search({
+          q: readString3(params, "q") ?? readString3(params, "query", { required: true }),
+          topicId: readTopicId4(params),
+          targetId: readString3(params, "targetId"),
+          limit: readNumber2(params, "limit"),
+          cursor: readString3(params, "cursor")
+        });
+        return response.data;
+      }
+    ),
+    add_evidence: contractToHandler(
+      MCP_TOOL_CONTRACTS.add_evidence,
+      async (params) => {
+        return lucern.evidence.add({
+          canonicalText: readString3(params, "canonicalText", { required: true }),
+          topicId: readTopicId4(params, { required: true }),
+          sourceUrl: readString3(params, "sourceUrl"),
+          supports: {
+            nodeId: readString3(params, "targetNodeId", { required: true }),
+            weight: readNumber2(params, "weight") ?? 1,
+            reasoning: readString3(params, "reasoning")
+          },
+          title: readString3(params, "title"),
+          content: readString3(params, "content"),
+          contentType: readString3(params, "contentType"),
+          metadata: readMetadata(params)
+        });
+      }
+    ),
+    link_evidence_to_belief: contractToHandler(
+      MCP_TOOL_CONTRACTS.link_evidence_to_belief,
+      async (params) => {
+        return lucern.evidence.linkToBelief({
+          evidenceId: readString3(params, "evidenceId", { required: true }),
+          beliefId: readString3(params, "beliefId", { required: true }),
+          weight: readNumber2(params, "weight", { required: true }),
+          rationale: readString3(params, "rationale")
+        });
+      }
+    )
+  };
+}
 
 // src/handlers/functionSurface.ts
 function camelCaseToolName(name) {
@@ -21908,6 +23474,21 @@ function mapWorktreeStatus(status) {
   }
   return;
 }
+function readMergeOutcomes(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => {
+    if (typeof entry === "string") {
+      const finding = entry.trim();
+      return finding ? finding : null;
+    }
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      return null;
+    }
+    return entry;
+  }).filter((entry) => entry !== null);
+}
 function createWorktreeHandlers(context) {
   const workflow = createWorkflowClient(context.sdkConfig);
   return {
@@ -22018,7 +23599,7 @@ function createWorktreeHandlers(context) {
     ),
     merge: contractToHandler(MCP_TOOL_CONTRACTS.merge, async (params) => {
       const worktreeId = readString3(params, "worktreeId", { required: true });
-      const outcomes = Array.isArray(params.outcomes) ? params.outcomes : [];
+      const outcomes = readMergeOutcomes(params.outcomes);
       const result = await workflow.merge(worktreeId, {
         outcomes,
         summary: readString3(params, "summary")