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

package/dist/runtime.js

@@ -3,10 +3,6 @@ import * as path2 from 'path';
 import { basename, extname } from 'path';
 import { z } from 'zod';
 import { v } from 'convex/values';
-import { internal, components, api as api$1 } from '@lucern/reasoning-kernel/adapters/convex';
-import 'stream';
-import { AsyncLocalStorage } from 'async_hooks';
-import { ConvexHttpClient } from 'convex/browser';
 import 'crypto';
 import * as os from 'os';
 
@@ -2054,6 +2050,40 @@ defineTable({
     { kind: "index", name: "by_tier_window_end", columns: ["tier", "windowEndMs"] }
   ]
 });
+defineTable({
+  name: "oauthDeviceCodes",
+  component: "mc",
+  category: "identity",
+  shape: z.object({
+    "deviceCodeHash": z.string(),
+    "userCode": z.string(),
+    "clientId": z.string(),
+    "scope": z.string(),
+    "status": z.enum(["pending", "approved", "denied", "expired", "consumed"]),
+    "expiresAt": z.number(),
+    "intervalSeconds": z.number(),
+    "lastPolledAt": z.number().optional(),
+    "slowDownCount": z.number().optional(),
+    "clerkUserId": z.string().optional(),
+    "tenantId": idOf("tenants").optional(),
+    "workspaceId": z.string().optional(),
+    "principalId": z.string().optional(),
+    "role": z.string().optional(),
+    "scopes": z.array(z.string()).optional(),
+    "sessionId": z.string().optional(),
+    "approvedAt": z.number().optional(),
+    "deniedAt": z.number().optional(),
+    "consumedAt": z.number().optional(),
+    "createdAt": z.number(),
+    "updatedAt": z.number()
+  }),
+  indices: [
+    { kind: "index", name: "by_deviceCodeHash", columns: ["deviceCodeHash"] },
+    { kind: "index", name: "by_userCode", columns: ["userCode"] },
+    { kind: "index", name: "by_status_expiresAt", columns: ["status", "expiresAt"] },
+    { kind: "index", name: "by_sessionId", columns: ["sessionId"] }
+  ]
+});
 defineTable({
   name: "servicePrincipalKeys",
   component: "mc",
@@ -11680,354 +11710,14 @@ new Map(
 // ../contracts/src/v1/topics/v1.ts
 var ROOT_TOPIC_ID = "n17tm38rwet7wqgzrmwahyt1z582590y";
 
-// ../server-core/src/kernelApi.ts
-var REQUIRED_KERNEL_API_REF_SUFFIXES = [
-  "contradictions.create",
-  "contradictions.getById",
-  "contradictions.getByTopic",
-  "epistemicAnswers.create",
-  "epistemicAnswers.getLatestForQuestion",
-  "epistemicBeliefs.archive",
-  "epistemicBeliefs.batchUpdateCriticality",
-  "epistemicBeliefs.create",
-  "epistemicBeliefs.forkBelief",
-  "epistemicBeliefs.getById",
-  "epistemicBeliefs.getByTopic",
-  "epistemicBeliefs.getConfidenceHistory",
-  "epistemicBeliefs.getLineage",
-  "epistemicBeliefs.getRelationships",
-  "epistemicBeliefs.linkBeliefs",
-  "epistemicBeliefs.linkEvidence",
-  "epistemicBeliefs.modulateConfidence",
-  "epistemicBeliefs.reassignBeliefsTopic",
-  "epistemicBeliefs.refineBelief",
-  "epistemicBeliefs.unlinkEvidence",
-  "epistemicBeliefs.updateCriticality",
-  "epistemicBeliefs.updateRationale",
-  "epistemicBeliefs.updateStatus",
-  "epistemicContracts.createEpistemicContract",
-  "epistemicContracts.evaluateContract",
-  "epistemicContracts.getContractStatus",
-  "epistemicEdges.batchCreate",
-  "epistemicEdges.create",
-  "epistemicEdges.deleteEdges",
-  "epistemicEdges.getBySourceNode",
-  "epistemicEdges.getByTopicAndType",
-  "epistemicEdges.remove",
-  "epistemicEdges.removeBetween",
-  "epistemicEdges.update",
-  "epistemicEvidence.create",
-  "epistemicEvidence.flagAsIncorrect",
-  "epistemicEvidence.getById",
-  "epistemicEvidence.getByTopic",
-  "epistemicEvidence.getForBelief",
-  "epistemicEvidence.remove",
-  "epistemicEvidence.update",
-  "epistemicEvidence.updateStatus",
-  "epistemicEvidence.updateVerificationStatus",
-  "epistemicNodes.get",
-  "epistemicNodes.getByGlobalId",
-  "epistemicQuestions.addQuestion",
-  "epistemicQuestions.advanceToConviction",
-  "epistemicQuestions.create",
-  "epistemicQuestions.createBatch",
-  "epistemicQuestions.deleteQuestion",
-  "epistemicQuestions.finalizeConviction",
-  "epistemicQuestions.getById",
-  "epistemicQuestions.getByTopic",
-  "epistemicQuestions.internalCreate",
-  "epistemicQuestions.updateConviction",
-  "epistemicQuestions.updatePriority",
-  "epistemicQuestions.updateQuestion",
-  "epistemicQuestions.updateStatus",
-  "evidenceClassifier.classifyEvidence",
-  "evidenceClassifier.classifyEvidenceBatch",
-  "graphAnalysisCache.getCachedAnalysis",
-  "graphIntelligence.analyzeProject",
-  "neo4jEdgeAPI.getGraphNeighborhood",
-  "neo4jQueries.getConfirmationBiasScore",
-  "ontologyDefinitions.archiveOntologyDefinition",
-  "ontologyDefinitions.createOntologyDefinition",
-  "ontologyDefinitions.createOntologyVersion",
-  "ontologyDefinitions.deprecateOntologyVersion",
-  "ontologyDefinitions.getOntologyDefinition",
-  "ontologyDefinitions.getOntologyDefinitionByKey",
-  "ontologyDefinitions.getPublishedVersion",
-  "ontologyDefinitions.listOntologyDefinitions",
-  "ontologyDefinitions.publishOntologyVersion",
-  "ontologyDefinitions.resolveEffectiveOntology",
-  "ontologyDefinitions.updateOntologyDefinition",
-  "policy.filterByPermission",
-  "questionEvidenceLinks.create",
-  "questionEvidenceLinks.getEvidenceWithDetails",
-  "tasks.complete",
-  "tasks.create",
-  "tasks.get",
-  "tasks.getByTopic",
-  "tasks.getByWorktree",
-  "tasks.update",
-  "topics.bulkCreate",
-  "topics.checkAccess",
-  "topics.create",
-  "topics.get",
-  "topics.getTree",
-  "topics.list",
-  "topics.listByOntology",
-  "topics.remove",
-  "topics.resolveTopicOntology",
-  "topics.update",
-  "worktrees.activate",
-  "worktrees.advancePhase",
-  "worktrees.bulkCreate",
-  "worktrees.complete",
-  "worktrees.create",
-  "worktrees.get",
-  "worktrees.list",
-  "worktrees.listAll",
-  "worktrees.patchState",
-  "worktrees.setPhase",
-  "worktrees.updateMetadata",
-  "worktrees.updateTargets"
-];
-var KERNEL_API_REF_MANIFEST = REQUIRED_KERNEL_API_REF_SUFFIXES.map((path3) => ({
-  path: `api.${path3}`,
-  componentPath: `components.lucern.${path3}`
-}));
-var GLOBAL_KEY = "__LUCERN_SERVER_CORE_KERNEL_API_BINDING__";
-function store() {
-  return globalThis;
-}
-function registerKernelApi(nextBinding) {
-  assertKernelApiBinding(nextBinding);
-  store()[GLOBAL_KEY] = nextBinding;
-}
-function getBinding() {
-  const current = store()[GLOBAL_KEY];
-  if (!current) {
-    throw new Error(
-      "Server-core kernelApi not registered. Call registerKernelApi({api, components, internal}) at host boot."
-    );
-  }
-  return current;
-}
-function readPath(root, path3) {
-  let cursor = root;
-  for (const part of path3) {
-    if (cursor == null || typeof cursor !== "object") {
-      return void 0;
-    }
-    cursor = cursor[part];
-  }
-  return cursor;
-}
-function resolveApiPath(binding, which, path3) {
-  return readPath(binding[which], path3);
-}
-function validateKernelApiBinding(binding) {
-  const missing = [];
-  const resolved = [];
-  for (const entry of KERNEL_API_REF_MANIFEST) {
-    const suffix = entry.path.split(".").slice(1);
-    const reference = resolveApiPath(binding, "api", suffix);
-    if (reference === void 0) {
-      missing.push(entry);
-    } else {
-      resolved.push(entry);
-    }
-  }
-  return {
-    ok: missing.length === 0,
-    missing,
-    resolved
-  };
-}
-function assertKernelApiBinding(binding) {
-  const result = validateKernelApiBinding(binding);
-  if (!result.ok) {
-    const refs = result.missing.map((entry) => entry.path).join(", ");
-    throw new Error(
-      `Server-core kernelApi binding is missing required refs: ${refs}`
-    );
-  }
-}
-function makeProxy(which, path3 = []) {
-  return new Proxy({}, {
-    get(_target, prop) {
-      if (typeof prop !== "string") {
-        return void 0;
-      }
-      const nextPath = [...path3, prop];
-      const resolved = resolveApiPath(getBinding(), which, nextPath);
-      return resolved === void 0 ? makeProxy(which, nextPath) : resolved;
-    }
-  });
-}
-var api = makeProxy("api");
-makeProxy("components");
-makeProxy("internal");
-
-// ../../apps/mcp-server/src/kernelApi.ts
-registerKernelApi({
-  api: api$1,
-  components: components,
-  internal: internal
+// ../../apps/mcp-server/src/runtime-context.ts
+var runtimeContext = Object.freeze({
+  transportKind: "stdio"
 });
-var api2 = api$1;
-var components2 = components;
-function isQuietMcpBoot() {
-  return process.env.LUCERN_MCP_QUIET === "1";
-}
-function logMcpInfo(message) {
-  if (!isQuietMcpBoot()) {
-    console.error(message);
-  }
+function getMcpRuntimeContext() {
+  return runtimeContext;
 }
 
-// ../../apps/mcp-server/src/convex-client.ts
-var _requestScopedClient = new AsyncLocalStorage();
-function runWithScopedClient(client, fn) {
-  return _requestScopedClient.run(client, fn);
-}
-function createAdminClient(url, deployKey) {
-  const client = new ConvexHttpClient(url);
-  client.setAdminAuth(deployKey);
-  return client;
-}
-var _lucernClient = null;
-function getLucernClient() {
-  const scoped = _requestScopedClient.getStore();
-  if (scoped) {
-    return scoped;
-  }
-  if (_lucernClient) {
-    return _lucernClient;
-  }
-  const url = process.env.LUCERN_CONVEX_URL;
-  const key = process.env.LUCERN_DEPLOY_KEY;
-  if (!url) {
-    throw new Error(
-      "LUCERN_CONVEX_URL is required. Ensure LUCERN_API_KEY is set in .env.lucern"
-    );
-  }
-  if (!key) {
-    throw new Error(
-      "LUCERN_DEPLOY_KEY is required. Ensure LUCERN_API_KEY is set in .env.lucern"
-    );
-  }
-  _lucernClient = new ConvexHttpClient(url);
-  _lucernClient.setAdminAuth(key);
-  logMcpInfo(`[lucern-graph] Lucern client initialized \u2192 ${url}`);
-  return _lucernClient;
-}
-var MCP_META_KEYS = [
-  "mcpSessionId",
-  "mcpToolName",
-  "runtimeToolName",
-  "runtimePackKey",
-  "runtimePackInstallScope"
-];
-var mutationRuntimeCache = /* @__PURE__ */ new Map();
-var packInstallScopeCache = /* @__PURE__ */ new Map();
-async function resolvePackInstallScope(packKey) {
-  const normalizedPackKey = packKey.trim();
-  if (!normalizedPackKey) {
-    return;
-  }
-  let cached = packInstallScopeCache.get(normalizedPackKey);
-  if (!cached) {
-    cached = (async () => {
-      const packDefinition = await mcAdminQuery(
-        "packs:getPackDefinition",
-        {
-          packKey: normalizedPackKey
-        }
-      );
-      const installScope = packDefinition?.installScope;
-      if (installScope === "tenant" || installScope === "workspace") {
-        return installScope;
-      }
-      throw new Error(
-        `[mcp-runtime] Pack "${normalizedPackKey}" is missing a valid installScope`
-      );
-    })();
-    packInstallScopeCache.set(normalizedPackKey, cached);
-  }
-  return await cached;
-}
-async function resolveMutationRuntimeFields(toolName) {
-  if (typeof toolName !== "string" || toolName.trim().length === 0) {
-    return null;
-  }
-  const normalizedToolName = toolName.trim();
-  let cached = mutationRuntimeCache.get(normalizedToolName);
-  if (!cached) {
-    cached = (async () => {
-      const tools = await adminQuery("toolAccess:listToolRegistry", {});
-      const tool = tools.find(
-        (candidate) => candidate?.toolName === normalizedToolName && candidate?.isActive !== false && candidate?.status !== "deprecated" && candidate?.status !== "disabled"
-      );
-      const packKey = typeof tool?.packKey === "string" ? tool.packKey.trim() : "";
-      if (!packKey) {
-        return { runtimeToolName: normalizedToolName };
-      }
-      return {
-        runtimeToolName: normalizedToolName,
-        runtimePackKey: packKey,
-        runtimePackInstallScope: await resolvePackInstallScope(packKey)
-      };
-    })();
-    mutationRuntimeCache.set(normalizedToolName, cached);
-  }
-  return await cached;
-}
-async function adminMutation(fn, args) {
-  const cleanArgs = { ...args };
-  if (cleanArgs.runtimeToolName === void 0 && cleanArgs.runtimePackKey === void 0 && cleanArgs.runtimePackInstallScope === void 0) {
-    const runtimeFields = await resolveMutationRuntimeFields(args?.mcpToolName);
-    if (runtimeFields) {
-      Object.assign(cleanArgs, runtimeFields);
-    }
-  }
-  for (const key of MCP_META_KEYS) {
-    delete cleanArgs[key];
-  }
-  return getLucernClient().mutation(fn, cleanArgs);
-}
-async function adminQuery(fn, args) {
-  return getLucernClient().query(fn, args);
-}
-var _mcClient = null;
-var _mcClientChecked = false;
-function getMcClient() {
-  if (_mcClientChecked) {
-    return _mcClient;
-  }
-  const url = process.env.MC_CONVEX_URL;
-  const key = process.env.MC_DEPLOY_KEY;
-  if (url && key) {
-    _mcClient = new ConvexHttpClient(url);
-    _mcClient.setAdminAuth(key);
-    logMcpInfo(`[lucern-graph] Master Control client initialized \u2192 ${url}`);
-  } else {
-    logMcpInfo(
-      "[lucern-graph] Master Control client not configured (no MC_CONVEX_URL). Methodology packs will use hardcoded fallback."
-    );
-  }
-  _mcClientChecked = true;
-  return _mcClient;
-}
-async function mcAdminQuery(fn, args) {
-  const c = getMcClient();
-  if (!c) {
-    throw new Error(
-      "Master Control client not configured (set MC_CONVEX_URL + MC_DEPLOY_KEY)"
-    );
-  }
-  return c.query(fn, args);
-}
-process.env.LUCERN_AGENT_IDENTITY || "agent:claude-code";
-crypto.randomUUID();
-
 // ../../apps/mcp-server/src/scope.ts
 var defaultTopicId = null;
 var PUBLIC_TOPIC_PREFIX = "top_";
@@ -12059,6 +11749,31 @@ function readLucernJson() {
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
+function getLucernClient() {
+  const client = getMcpRuntimeContext().lucernClient;
+  if (!client) {
+    throw new Error("[scope] Lucern SDK client is not initialized.");
+  }
+  return client;
+}
+function unwrapGatewayData(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const data = record.data;
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    return data;
+  }
+  return record;
+}
+function readRecordId(record) {
+  if (!record) {
+    return void 0;
+  }
+  const candidate = record._id ?? record.id ?? record.topicId ?? record.nodeId;
+  return isNonEmptyString(candidate) ? candidate : void 0;
+}
 function readTopicMappedProjectId(topic) {
   const metadata = topic.metadata || {};
   const candidate = metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
@@ -12070,27 +11785,23 @@ async function tryGetTopicById(topicId) {
     return null;
   }
   try {
-    const topic = await adminQuery(components2.lucern.topics.get, {
-      id: normalizedTopicId
-    });
-    return topic || null;
+    return unwrapGatewayData(await getLucernClient().topics.get(normalizedTopicId));
   } catch {
     return null;
   }
 }
 async function tryGetNodeById(nodeId) {
   try {
-    const node = await adminQuery(api2.epistemicNodes.getInternal, {
-      nodeId
-    });
-    return node || null;
+    return unwrapGatewayData(await getLucernClient().nodes.get({ nodeId }));
   } catch {
     return null;
   }
 }
 async function findTopicByMappedProjectId(legacyScopeId) {
   try {
-    const topics2 = await adminQuery(components2.lucern.topics.list, {});
+    const response = await getLucernClient().topics.list({});
+    const data = unwrapGatewayData(response);
+    const topics2 = Array.isArray(data?.topics) ? data.topics : Array.isArray(data?.items) ? data.items : [];
     return topics2.find((topic) => readTopicMappedProjectId(topic) === legacyScopeId) || null;
   } catch {
     return null;
@@ -12124,7 +11835,7 @@ async function resolveTopicScopeId(scopeId, toolName) {
   if (!resolved) {
     const mappedTopic = normalizedScopeId ? await findTopicByMappedProjectId(normalizedScopeId) : null;
     if (mappedTopic) {
-      resolved = String(mappedTopic._id);
+      resolved = readRecordId(mappedTopic);
     }
   }
   if (!resolved) {
@@ -12323,314 +12034,6 @@ var beliefHandlers = {
   }
 };
 
-// ../../apps/mcp-server/src/handlers/bootstrap-session.ts
-function slugify(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
-}
-async function resolveBeliefs(nodeIds) {
-  const results = [];
-  for (const nodeId of nodeIds) {
-    try {
-      const node = await adminQuery(api2.epistemicNodes.get, {
-        nodeId
-      });
-      if (!node) {
-        continue;
-      }
-      results.push({
-        nodeId,
-        text: String(node.canonicalText || "").slice(0, 200),
-        confidence: typeof node.confidence === "number" ? node.confidence : null
-      });
-    } catch {
-    }
-  }
-  return results;
-}
-async function resolveQuestions(nodeIds) {
-  const results = [];
-  for (const nodeId of nodeIds) {
-    try {
-      const node = await adminQuery(api2.epistemicNodes.get, {
-        nodeId
-      });
-      if (!node) {
-        continue;
-      }
-      const metadata = node.metadata || {};
-      results.push({
-        nodeId,
-        text: String(node.canonicalText || "").slice(0, 200),
-        status: String(metadata.questionStatus || node.status || "open"),
-        priority: String(metadata.priority || "medium")
-      });
-    } catch {
-    }
-  }
-  return results;
-}
-async function beginBuildSession(args) {
-  const worktreeId = typeof args.worktreeId === "string" ? args.worktreeId : void 0;
-  if (!worktreeId) {
-    throw new Error("[begin_build_session] worktreeId is required");
-  }
-  const branch = typeof args.branch === "string" && args.branch.trim().length > 0 ? args.branch.trim() : void 0;
-  const branchBase = typeof args.branchBase === "string" && args.branchBase.trim().length > 0 ? args.branchBase.trim() : "staging";
-  const prBase = typeof args.prBase === "string" && args.prBase.trim().length > 0 ? args.prBase.trim() : "staging";
-  const sessionMode = typeof args.sessionMode === "string" && args.sessionMode.trim().length > 0 ? args.sessionMode.trim() : "async";
-  const activateIfPlanning = args.activateIfPlanning !== false;
-  const worktree = await adminQuery(components2.lucern.worktrees.get, {
-    worktreeId
-  });
-  if (!worktree) {
-    throw new Error(`Worktree ${worktreeId} not found`);
-  }
-  const worktreeName = String(worktree.name || "Untitled");
-  const topicId = String(worktree.topicId || "");
-  const campaign = typeof worktree.campaign === "number" ? worktree.campaign : null;
-  const lane = String(worktree.lane || "unlaned");
-  const laneOrderInCampaign = typeof worktree.laneOrderInCampaign === "number" ? worktree.laneOrderInCampaign : null;
-  const orderInLane = typeof worktree.orderInLane === "number" ? worktree.orderInLane : null;
-  const gate = String(worktree.gate || "");
-  const hypothesis = String(worktree.hypothesis || worktree.beliefFocus || "");
-  let status = String(worktree.status || "planning");
-  const dependsOn = worktree.dependsOn || [];
-  const blocks = worktree.blocks || [];
-  const targetBeliefIds = worktree.targetBeliefIds || [];
-  const targetQuestionIds = worktree.targetQuestionIds || [];
-  if (activateIfPlanning && status === "planning") {
-    try {
-      await adminMutation(components2.lucern.worktrees.activate, {
-        worktreeId
-      });
-      status = "active";
-    } catch {
-    }
-  }
-  let topicName = "Unknown";
-  try {
-    const topic = await adminQuery(components2.lucern.topics.get, {
-      id: topicId
-    });
-    if (topic) {
-      topicName = String(topic.name || "Unknown");
-    }
-  } catch {
-  }
-  const allBeliefs = await resolveBeliefs(targetBeliefIds);
-  const topBeliefs = allBeliefs.slice().sort((left, right) => (right.confidence ?? -1) - (left.confidence ?? -1)).slice(0, 8);
-  const allQuestions = await resolveQuestions(targetQuestionIds);
-  const openQuestions = [];
-  const resolvedDecisions = [];
-  for (const question of allQuestions) {
-    const questionStatus = question.status.toLowerCase();
-    if (questionStatus === "answered" || questionStatus === "resolved") {
-      let decision = "(decision recorded \u2014 call get_answer for details)";
-      try {
-        const answer = await adminQuery(
-          api2.epistemicAnswers.getLatestForQuestion,
-          {
-            questionNodeId: question.nodeId
-          }
-        );
-        if (answer) {
-          decision = String(
-            answer.answerText || answer.canonicalText || decision
-          ).slice(0, 200);
-        }
-      } catch {
-        try {
-          const node = await adminQuery(api2.epistemicNodes.get, {
-            nodeId: question.nodeId
-          });
-          if (node?._id) {
-            const answer = await adminQuery(
-              api2.epistemicAnswers.getLatestForQuestion,
-              {
-                questionNodeId: node._id
-              }
-            );
-            if (answer) {
-              decision = String(
-                answer.answerText || answer.canonicalText || decision
-              ).slice(0, 200);
-            }
-          }
-        } catch {
-        }
-      }
-      resolvedDecisions.push({
-        question: question.text.slice(0, 150),
-        decision
-      });
-      continue;
-    }
-    openQuestions.push({
-      nodeId: question.nodeId,
-      text: question.text,
-      priority: question.priority
-    });
-  }
-  try {
-    const topicQuestions = await adminQuery(api2.epistemicQuestions.getByTopic, {
-      topicId,
-      userId: "system",
-      limit: 20
-    }).catch(() => []);
-    for (const question of Array.isArray(topicQuestions) ? topicQuestions : []) {
-      const metadata = question.metadata || {};
-      const questionStatus = String(
-        metadata.questionStatus || question.status || "open"
-      ).toLowerCase();
-      if ((questionStatus === "open" || questionStatus === "in_progress") && !targetQuestionIds.includes(String(question._id))) {
-        openQuestions.push({
-          nodeId: String(question._id),
-          text: String(question.canonicalText || "").slice(0, 200),
-          priority: String(metadata.priority || "medium")
-        });
-      }
-    }
-  } catch {
-  }
-  const dependencies = [];
-  for (const dependencyId of dependsOn.slice(0, 5)) {
-    try {
-      const dependency = await adminQuery(components2.lucern.worktrees.get, {
-        worktreeId: dependencyId
-      });
-      dependencies.push({
-        worktreeId: dependencyId,
-        title: String(dependency?.name || "Unknown"),
-        status: String(dependency?.status || "unknown")
-      });
-    } catch {
-      dependencies.push({
-        worktreeId: dependencyId,
-        title: "Unknown",
-        status: "unknown"
-      });
-    }
-  }
-  const unblocks = [];
-  for (const blockedId of blocks.slice(0, 5)) {
-    try {
-      const blocked = await adminQuery(components2.lucern.worktrees.get, {
-        worktreeId: blockedId
-      });
-      unblocks.push({
-        worktreeId: blockedId,
-        title: String(blocked?.name || "Unknown")
-      });
-    } catch {
-      unblocks.push({
-        worktreeId: blockedId,
-        title: "Unknown"
-      });
-    }
-  }
-  const effectiveBranch = branch || `codex/${slugify(worktreeName)}`;
-  const incompleteDependencies = dependencies.filter(
-    (dependency) => dependency.status !== "completed" && dependency.status !== "merged"
-  );
-  const mergeOrderNotes = incompleteDependencies.length > 0 ? `Blocked by: ${incompleteDependencies.map((dependency) => dependency.title).join(", ")}` : "none";
-  const requiredDocs = [
-    "docs/api/EK-13-api-sdk-architecture.md",
-    "docs/api/EK-13.1.5-repo-architecture-blueprint.md",
-    "docs/api/EK-13.1-contract-authority.md",
-    "docs/development/handoff-contract.md"
-  ];
-  const focus = hypothesis ? `${hypothesis.split(".")[0]}.` : `Complete ${worktreeName}`;
-  const exitCriteria = gate ? [`Gate: ${gate}`] : [];
-  exitCriteria.push(
-    "All namespace surfaces end-to-end: contract \u2192 domain \u2192 HTTP \u2192 SDK \u2192 MCP \u2192 test",
-    "All code lands in target-state paths under lucern/",
-    "PR targets staging, not main"
-  );
-  const keyFiles = [
-    "app/api/platform/v1/_lib/gateway.ts",
-    "modules/access-control/src/principalContext.ts",
-    "lucern/packages/sdk/src/coreClient.ts",
-    "lucern/packages/sdk/src/identityClient.ts",
-    "lucern/contracts/src/sdk-methods.contract.ts",
-    "app/api/platform/v1/identity/"
-  ];
-  const pillarKeywords = [
-    "Pillar 1",
-    "Pillar 2",
-    "Pillar 3",
-    "Pillar 4",
-    "Pillar 5",
-    "Pillar 6",
-    "Pillar 7",
-    "Pillar 8",
-    "8 innovation pillars"
-  ];
-  const pillarBeliefs = [];
-  for (const belief of allBeliefs) {
-    for (const keyword of pillarKeywords) {
-      if (!belief.text.includes(keyword)) {
-        continue;
-      }
-      const pillarMatch = belief.text.match(/Pillar \d+ \([^)]+\)/);
-      pillarBeliefs.push({
-        pillar: pillarMatch ? pillarMatch[0] : keyword,
-        text: belief.text.slice(0, 250),
-        nodeId: belief.nodeId
-      });
-      break;
-    }
-  }
-  const visionDocs = [
-    {
-      path: "docs/product/core-value-propositions.md",
-      description: "8 innovation pillars through developer, marketing, and investor lenses"
-    },
-    {
-      path: "docs/product/five-domains.md",
-      description: "5 product domains: MC, Tenant, Developer, Reasoning Control, Reasoning"
-    },
-    {
-      path: "docs/product/innovation-pillars.md",
-      description: "The 8 pillars that define what makes Lucern unique"
-    },
-    {
-      path: "docs/product/vision-to-roadmap-bridge.md",
-      description: "Where each pillar is today vs. where it goes \u2014 the north star trajectory"
-    }
-  ];
-  return {
-    topicId,
-    topicName,
-    worktreeId,
-    worktreeName,
-    branch: effectiveBranch,
-    branchBase,
-    prBase,
-    campaign,
-    lane,
-    laneOrderInCampaign,
-    orderInLane,
-    gate,
-    hypothesis,
-    focus,
-    status,
-    sessionMode,
-    targetBeliefIds,
-    targetQuestionIds,
-    topBeliefs,
-    openQuestions,
-    resolvedDecisions,
-    exitCriteria,
-    requiredDocs,
-    keyFiles,
-    pillarBeliefs,
-    visionDocs,
-    dependencies,
-    unblocks,
-    mergeOrderNotes
-  };
-}
-
 // ../../apps/mcp-server/src/handlers/bootstrap.ts
 var bootstrapHandlers = {
   async generate_session_handoff(args, ctx) {
@@ -12639,7 +12042,9 @@ var bootstrapHandlers = {
     );
   },
   async begin_build_session(args, ctx) {
-    return beginBuildSession(args);
+    return formatSdkResult(
+      await getSdkClient(ctx).mcp.beginBuildSession(args)
+    );
   }
 };
 
@@ -12995,19 +12400,16 @@ var engineeringVerificationHandlers = {
         "evaluate_engineering_contract requires at least one verification payload."
       );
     }
-    const result = await adminMutation(
-      "epistemicContracts:evaluateEngineeringContracts",
-      {
+    return formatSdkResult(
+      await getSdkClient(ctx).mcp.evaluateEngineeringContract({
         beliefNodeId: args.beliefNodeId,
         trigger: args.trigger,
         testOutput: args.testOutput,
         tscOutput: args.tscOutput,
         lintOutput: args.lintOutput,
-        sentryData: args.sentryData,
-        authenticatedUserId: ctx.userId
-      }
+        sentryData: args.sentryData
+      })
     );
-    return result;
   }
 };
 
@@ -13960,6 +13362,47 @@ var intelligenceHandlers = {
   get_graph_structure_analysis: graphHandlers.get_graph_structure_analysis,
   get_falsification_questions: graphHandlers.get_falsification_questions
 };
+var GLOBAL_KEY = "__LUCERN_SERVER_CORE_KERNEL_API_BINDING__";
+function store() {
+  return globalThis;
+}
+function getBinding() {
+  const current = store()[GLOBAL_KEY];
+  if (!current) {
+    throw new Error(
+      "Server-core kernelApi not registered. Call registerKernelApi({api, components, internal}) at host boot."
+    );
+  }
+  return current;
+}
+function readPath(root, path3) {
+  let cursor = root;
+  for (const part of path3) {
+    if (cursor == null || typeof cursor !== "object") {
+      return void 0;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function resolveApiPath(binding, which, path3) {
+  return readPath(binding[which], path3);
+}
+function makeProxy(which, path3 = []) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop !== "string") {
+        return void 0;
+      }
+      const nextPath = [...path3, prop];
+      const resolved = resolveApiPath(getBinding(), which, nextPath);
+      return resolved === void 0 ? makeProxy(which, nextPath) : resolved;
+    }
+  });
+}
+var api = makeProxy("api");
+makeProxy("components");
+makeProxy("internal");
 
 // ../server-core/src/mcp-context-tools.ts
 function requireMcpConvex(authContext, label) {
@@ -15025,16 +14468,16 @@ function buildInputData(args) {
 var researchVerificationHandlers = {
   async evaluate_research_contract(args, ctx) {
     const inputData = buildInputData(args);
-    const result = await adminMutation(
-      api2.contracts.evaluateContractsForTrigger,
-      {
+    return formatSdkResult(
+      await getSdkClient(ctx).mcp.evaluateResearchContract({
         beliefNodeId: args.beliefNodeId,
         trigger: typeof args.trigger === "string" && args.trigger.length > 0 ? args.trigger : "event_driven",
-        ...inputData ? { inputData } : {},
-        authenticatedUserId: ctx.userId
-      }
+        metricData: inputData?.metricData,
+        referenceCheckData: inputData?.referenceCheckData,
+        marketIndexData: inputData?.marketIndexData,
+        temporalData: inputData?.temporalData
+      })
     );
-    return result;
   }
 };
 
@@ -15586,6 +15029,20 @@ function recordWrite(toolName, topicId, sessionId = "default") {
   existing.push(record);
   sessionWritesBySession.set(sessionId, existing);
 }
+async function checkGatewayWritePolicy(args) {
+  const client = args.authCtx.lucernClient;
+  const checkWritePolicy2 = client?.mcp?.checkWritePolicy;
+  if (!checkWritePolicy2) {
+    throw new Error("Lucern SDK MCP write-policy client is not initialized.");
+  }
+  const response = await checkWritePolicy2({
+    topicId: args.topicId,
+    workspaceId: args.authCtx.workspaceId,
+    role: args.authCtx.role,
+    toolName: args.toolName
+  });
+  return response.data ?? null;
+}
 function buildRateLimitExplanation(args) {
   const summary = `Denied ${args.toolName}: session write limit ${args.currentCount}/${args.maxWritesPerSession} reached for the matched write policy.`;
   return {
@@ -15623,10 +15080,10 @@ async function checkWritePolicy(toolName, topicId, authCtx) {
     return { allowed: true, permission: "allow", reason: "read_only_tool" };
   }
   try {
-    const result = await adminQuery("mcpWritePolicy:checkAccess", {
+    const result = await checkGatewayWritePolicy({
       topicId: topicId ?? void 0,
-      role: authCtx.role,
-      toolName
+      toolName,
+      authCtx
     });
     if (!result) {
       return {
@@ -15692,9 +15149,11 @@ async function checkWritePolicy(toolName, topicId, authCtx) {
     };
   }
 }
+
+// ../../apps/mcp-server/src/credentials.ts
 var LUCERN_HOME = path2.join(os.homedir(), ".lucern");
 path2.join(LUCERN_HOME, "credentials");
 
-export { buildHandlerMap, checkWritePolicy, createAdminClient, isMutationTool, recordWrite, runWithScopedClient };
+export { buildHandlerMap, checkWritePolicy, isMutationTool, recordWrite };
 //# sourceMappingURL=runtime.js.map
 //# sourceMappingURL=runtime.js.map