@lucern/mcp 0.2.0-alpha.1 → 0.2.0-alpha.10

package/dist/runtime.js

@@ -0,0 +1,2915 @@
+import * as fs from 'fs';
+import * as path2 from 'path';
+import { api, components, internal } from '@lucern/reasoning-kernel/_generated/api';
+import 'stream';
+import { AsyncLocalStorage } from 'async_hooks';
+import { ConvexHttpClient } from 'convex/browser';
+import 'crypto';
+import * as os from 'os';
+
+// ../../apps/mcp-server/src/handlers/sdk.ts
+var handlerSdkClientCache = /* @__PURE__ */ new WeakMap();
+async function resolveOntologyFromLookup(baseClient, input) {
+  const id = readString(input.id ?? input.ontologyId);
+  if (id) {
+    return baseClient.ontologies.get(id);
+  }
+  const ontologyKey = readString(input.ontologyKey);
+  if (!ontologyKey) {
+    return {
+      error: "Either id or ontologyKey is required."
+    };
+  }
+  const listResult = await baseClient.ontologies.list({
+    tenantId: readString(input.tenantId),
+    tier: readString(input.tier),
+    status: readString(input.status)
+  });
+  const payload = asRecord(listResult);
+  const rows = Array.isArray(payload.ontologies) ? payload.ontologies : Array.isArray(payload.definitions) ? payload.definitions : [];
+  const tenantId = readString(input.tenantId);
+  const match = rows.find((row) => {
+    const record = asRecord(row);
+    if (readString(record.ontologyKey) !== ontologyKey) {
+      return false;
+    }
+    if (!tenantId) {
+      return true;
+    }
+    return readString(record.tenantId) === tenantId;
+  });
+  return match ? asRecord(match) : {
+    error: `Ontology not found: ${ontologyKey}`
+  };
+}
+function buildHandlerSdkClient(ctx) {
+  const baseClient = ctx.lucernClient;
+  return {
+    ...baseClient,
+    ontologies: {
+      ...baseClient.ontologies,
+      get(input) {
+        return typeof input === "string" ? baseClient.ontologies.get(input) : resolveOntologyFromLookup(baseClient, input ?? {});
+      }
+    }
+  };
+}
+function getSdkClient(ctx) {
+  if (!ctx.lucernClient) {
+    throw new Error("Lucern SDK client is not available for this MCP runtime.");
+  }
+  const cached = handlerSdkClientCache.get(ctx);
+  if (cached) {
+    return cached;
+  }
+  const wrappedClient = buildHandlerSdkClient(ctx);
+  handlerSdkClientCache.set(ctx, wrappedClient);
+  return wrappedClient;
+}
+function formatSdkResult(value) {
+  if (value && typeof value === "object" && !Array.isArray(value) && "data" in value) {
+    const envelope = value;
+    if (envelope.data && typeof envelope.data === "object" && !Array.isArray(envelope.data)) {
+      return envelope.data;
+    }
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return { value };
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asJsonObject(value) {
+  const record = asRecord(value);
+  return Object.keys(record).length > 0 ? record : void 0;
+}
+function readString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function readNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value.trim());
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function readBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true") {
+      return true;
+    }
+    if (normalized === "false") {
+      return false;
+    }
+  }
+  return void 0;
+}
+function readStringArray(value) {
+  if (Array.isArray(value)) {
+    const items = value.map((entry) => readString(entry)).filter((entry) => Boolean(entry));
+    return items.length > 0 ? items : void 0;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    if (normalized.startsWith("[")) {
+      try {
+        const parsed = JSON.parse(normalized);
+        if (Array.isArray(parsed)) {
+          return readStringArray(parsed);
+        }
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function readTimeRange(value) {
+  const record = asRecord(value);
+  const start = readNumber(record.start);
+  const end = readNumber(record.end);
+  if (start === void 0 && end === void 0) {
+    return void 0;
+  }
+  return {
+    start: start ?? Number.NaN,
+    end: end ?? Number.NaN
+  };
+}
+
+// ../../apps/mcp-server/src/handlers/answers.ts
+var answerHandlers = {
+  async create_answer(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).answers.create({
+        questionNodeId: args.questionNodeId,
+        answerText: args.answerText,
+        confidence: args.confidence || "moderate",
+        evidenceNodeIds: args.evidenceNodeIds || [],
+        answerSource: args.answerSource || "ai_generated"
+      })
+    );
+  },
+  async get_answer(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).answers.get({
+        questionNodeId: args.questionNodeId
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/auto-branching.ts
+var autoBranchingHandlers = {
+  async analyze_topic_density(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).context.analyzeTopicDensity(args)
+    );
+  },
+  async apply_auto_branching(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).context.applyAutoBranching(args)
+    );
+  }
+};
+
+// ../contracts/src/ids.contract.ts
+var PREFIXED_ID_PATTERN = /^([a-z][a-z0-9]*)_(.+)$/;
+function encodePrefixedId(prefix, value) {
+  const normalizedPrefix = prefix.trim();
+  const normalizedValue = value.trim();
+  if (!normalizedPrefix || !normalizedValue) {
+    throw new Error("Both prefix and value are required to encode a prefixed ID.");
+  }
+  return `${normalizedPrefix}_${normalizedValue}`;
+}
+function decodePrefixedId(id) {
+  const normalized = id.trim();
+  const match = PREFIXED_ID_PATTERN.exec(normalized);
+  if (!match) {
+    throw new Error(`Invalid prefixed ID: ${id}`);
+  }
+  return {
+    prefix: match[1],
+    value: match[2]
+  };
+}
+
+// ../contracts/src/lens-filter.contract.ts
+function isLensFilterCriteria(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return typeof obj.version === "number" && typeof obj.kind === "string";
+}
+function isTaxonomyFilterCriteriaV1(value) {
+  if (!isLensFilterCriteria(value)) return false;
+  return value.version === 1 && value.kind === "taxonomy";
+}
+function validateFilterCriteria(value) {
+  if (value === void 0 || value === null) {
+    return { valid: true };
+  }
+  if (!isLensFilterCriteria(value)) {
+    return {
+      valid: false,
+      errors: [
+        'filterCriteria must have numeric "version" and string "kind" fields'
+      ]
+    };
+  }
+  if (isTaxonomyFilterCriteriaV1(value)) {
+    return validateTaxonomyFilterV1(value);
+  }
+  const raw = value;
+  return {
+    valid: false,
+    errors: [
+      `Unsupported filter criteria: version=${raw.version}, kind=${raw.kind}`
+    ]
+  };
+}
+function validateTaxonomyFilterV1(criteria) {
+  const errors = [];
+  if (!Array.isArray(criteria.entityTypeFilters)) {
+    errors.push("entityTypeFilters must be an array");
+    return { valid: false, errors };
+  }
+  if (criteria.entityTypeFilters.length === 0) {
+    errors.push("entityTypeFilters must contain at least one entry");
+    return { valid: false, errors };
+  }
+  for (let i = 0; i < criteria.entityTypeFilters.length; i++) {
+    const filter = criteria.entityTypeFilters[i];
+    if (!filter || typeof filter.entityTypeValue !== "string") {
+      errors.push(
+        `entityTypeFilters[${i}].entityTypeValue must be a non-empty string`
+      );
+      continue;
+    }
+    if (filter.entityTypeValue.trim().length === 0) {
+      errors.push(
+        `entityTypeFilters[${i}].entityTypeValue must be a non-empty string`
+      );
+    }
+    if (filter.subtypeValues !== void 0 && !Array.isArray(filter.subtypeValues)) {
+      errors.push(`entityTypeFilters[${i}].subtypeValues must be an array`);
+    }
+  }
+  if (criteria.ontologyScope !== void 0) {
+    if (typeof criteria.ontologyScope !== "object" || criteria.ontologyScope === null) {
+      errors.push("ontologyScope must be an object");
+    }
+  }
+  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+}
+
+// ../contracts/src/v1/topics/v1.ts
+var ROOT_TOPIC_ID = "n17tm38rwet7wqgzrmwahyt1z582590y";
+
+// ../server-core/src/kernelApi.ts
+var binding = null;
+function registerKernelApi(nextBinding) {
+  binding = nextBinding;
+}
+function getBinding() {
+  if (!binding) {
+    throw new Error(
+      "Server-core kernelApi not registered. Call registerKernelApi({api, components, internal}) at host boot."
+    );
+  }
+  return binding;
+}
+function makeProxy(which) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      return getBinding()[which][prop];
+    }
+  });
+}
+makeProxy("api");
+makeProxy("components");
+makeProxy("internal");
+
+// ../../apps/mcp-server/src/kernelApi.ts
+registerKernelApi({
+  api: api,
+  components: components,
+  internal: internal
+});
+var api2 = api;
+var components2 = components;
+function isQuietMcpBoot() {
+  return process.env.LUCERN_MCP_QUIET === "1";
+}
+function logMcpInfo(message) {
+  if (!isQuietMcpBoot()) {
+    console.error(message);
+  }
+}
+
+// ../../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 getLucernClient().query(
+        api2.toolAccess.getExecutableTools,
+        {}
+      );
+      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_";
+function decodePublicTopicId(topicId) {
+  if (!isNonEmptyString(topicId)) {
+    return void 0;
+  }
+  return topicId.startsWith(PUBLIC_TOPIC_PREFIX) ? topicId.slice(PUBLIC_TOPIC_PREFIX.length) : topicId;
+}
+function readTopicIdArg(args) {
+  const topicId = args.topicId;
+  const legacyProjectId = args.projectId;
+  return topicId || legacyProjectId || void 0;
+}
+var LUCERN_JSON_PATH = path2.resolve(process.cwd(), ".lucern.json");
+function readLucernJson() {
+  try {
+    const raw = fs.readFileSync(LUCERN_JSON_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      ...parsed,
+      topicId: parsed.topicId,
+      topicName: parsed.topicName
+    };
+  } catch {
+    return null;
+  }
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function readTopicMappedProjectId(topic) {
+  const metadata = topic.metadata || {};
+  const candidate = metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
+  return isNonEmptyString(candidate) ? candidate : void 0;
+}
+async function tryGetTopicById(topicId) {
+  const normalizedTopicId = decodePublicTopicId(topicId);
+  if (!normalizedTopicId) {
+    return null;
+  }
+  try {
+    const topic = await adminQuery(components2.lucern.topics.get, {
+      id: normalizedTopicId
+    });
+    return topic || null;
+  } catch {
+    return null;
+  }
+}
+async function tryGetNodeById(nodeId) {
+  try {
+    const node = await adminQuery(components2.lucern.epistemicNodes.getInternal, {
+      nodeId
+    });
+    return node || null;
+  } catch {
+    return null;
+  }
+}
+async function findTopicByMappedProjectId(legacyScopeId) {
+  try {
+    const topics = await adminQuery(components2.lucern.topics.list, {});
+    return topics.find((topic) => readTopicMappedProjectId(topic) === legacyScopeId) || null;
+  } catch {
+    return null;
+  }
+}
+async function resolveTopicScopeId(scopeId, toolName) {
+  let resolved;
+  const normalizedScopeId = decodePublicTopicId(scopeId);
+  if (!isNonEmptyString(scopeId)) {
+    if (isNonEmptyString(defaultTopicId)) {
+      resolved = defaultTopicId;
+    } else {
+      const lucernContext = readLucernJson();
+      const ambientTopicId = decodePublicTopicId(lucernContext?.topicId);
+      if (isNonEmptyString(ambientTopicId)) {
+        resolved = ambientTopicId;
+      }
+    }
+    if (!resolved) {
+      throw new Error(
+        `[${toolName}] Missing topic scope. Provide topicId.`
+      );
+    }
+  }
+  if (!resolved) {
+    const topic = normalizedScopeId ? await tryGetTopicById(normalizedScopeId) : null;
+    if (topic) {
+      resolved = String(topic._id);
+    }
+  }
+  if (!resolved) {
+    const mappedTopic = normalizedScopeId ? await findTopicByMappedProjectId(normalizedScopeId) : null;
+    if (mappedTopic) {
+      resolved = String(mappedTopic._id);
+    }
+  }
+  if (!resolved) {
+    const node = normalizedScopeId ? await tryGetNodeById(normalizedScopeId) : null;
+    if (node && isNonEmptyString(node.topicId)) {
+      resolved = node.topicId;
+    }
+  }
+  if (!resolved) {
+    throw new Error(
+      `[${toolName}] Scope "${scopeId}" is not a topic and has no mapped topic.`
+    );
+  }
+  return resolved;
+}
+function getDefaultScopeContext() {
+  const lucernContext = readLucernJson();
+  const ambientTopicId = decodePublicTopicId(lucernContext?.topicId);
+  if (ambientTopicId) {
+    return { topicId: ambientTopicId };
+  }
+  return { topicId: null };
+}
+
+// ../../apps/mcp-server/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(args) {
+  const belief = readNumber(args.belief);
+  const disbelief = readNumber(args.disbelief);
+  const uncertainty = readNumber(args.uncertainty);
+  const baseRate = readNumber(args.baseRate);
+  const tupleValues = [belief, disbelief, uncertainty, baseRate];
+  const providedCount = tupleValues.filter(
+    (value) => value !== void 0
+  ).length;
+  if (providedCount === 0 && readNumber(args.confidence ?? args.newConfidence) !== void 0) {
+    throw new Error(
+      JSON.stringify({
+        code: "AMBIGUOUS_SCALAR",
+        message: "Scalar confidence input is ambiguous without an explicit subjective-logic interpretation.",
+        suggestion: AMBIGUOUS_SCALAR_SUGGESTION
+      })
+    );
+  }
+  if (providedCount !== tupleValues.length) {
+    throw new Error(
+      "belief, disbelief, uncertainty, and baseRate must all be provided together."
+    );
+  }
+  return {
+    b: belief ?? 0,
+    d: disbelief ?? 0,
+    u: uncertainty ?? 0,
+    a: baseRate ?? 0.5
+  };
+}
+var beliefHandlers = {
+  async create_belief(args, ctx) {
+    const baseRate = readNumber(args.baseRate);
+    if (baseRate === void 0) {
+      throw new Error("baseRate is required for create_belief.");
+    }
+    if (baseRate < 0 || baseRate > 1) {
+      throw new Error("baseRate must be within [0, 1].");
+    }
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.create({
+        topicId: readString(readTopicIdArg(args)) ?? "",
+        text: readString(args.text ?? args.canonicalText ?? args.formulation) ?? "",
+        baseRate,
+        rationale: readString(args.rationale),
+        worktreeId: readString(args.worktreeId),
+        pillar: readString(args.pillar),
+        sourceBeliefIds: readStringArray(args.sourceBeliefIds),
+        sourceType: readString(args.sourceType),
+        beliefType: readString(args.beliefType),
+        reversibility: readString(args.reversibility),
+        predictionMeta: asJsonObject(args.predictionMeta),
+        metadata: asJsonObject(args.metadata)
+      })
+    );
+  },
+  async get_belief(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.get(
+        readString(args.id ?? args.nodeId ?? args.beliefId) ?? ""
+      )
+    );
+  },
+  async list_beliefs(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.list({
+        topicId: readString(readTopicIdArg(args)),
+        status: readString(args.status),
+        worktreeId: readString(args.worktreeId),
+        minConfidence: readNumber(args.minConfidence),
+        limit: readNumber(args.limit),
+        cursor: readString(args.cursor)
+      })
+    );
+  },
+  async refine_belief(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.refine(
+        readString(args.id ?? args.nodeId ?? args.beliefId) ?? "",
+        {
+          text: readString(args.canonicalText ?? args.text ?? args.formulation) ?? "",
+          rationale: readString(args.rationale)
+        }
+      )
+    );
+  },
+  async modulate_confidence(args, ctx) {
+    const opinion = readOpinionTuple(args);
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.modulateConfidence(
+        readString(args.id ?? args.nodeId ?? args.beliefId) ?? "",
+        {
+          opinion,
+          trigger: readString(args.trigger),
+          rationale: readString(args.rationale) ?? "",
+          maxInlinePropagationTargets: readNumber(
+            args.maxInlinePropagationTargets
+          )
+        }
+      )
+    );
+  },
+  async fork_belief(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.fork(
+        readString(args.id ?? args.nodeId ?? args.beliefId) ?? "",
+        {
+          text: readString(args.text ?? args.newFormulation ?? args.formulation) ?? "",
+          forkReason: readString(args.forkReason),
+          rationale: readString(args.rationale)
+        }
+      )
+    );
+  },
+  async archive_belief(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.archive(
+        readString(args.id ?? args.nodeId ?? args.beliefId) ?? "",
+        {
+          reason: readString(args.reason ?? args.rationale)
+        }
+      )
+    );
+  },
+  async query_lineage(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.lineage(
+        readString(args.id ?? args.nodeId ?? args.beliefId) ?? ""
+      )
+    );
+  },
+  async get_confidence_history(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.confidenceHistory(
+        readString(args.id ?? args.nodeId ?? args.beliefId) ?? ""
+      )
+    );
+  },
+  async create_epistemic_contract(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.createContract(
+        readString(
+          args.id ?? args.nodeId ?? args.beliefId ?? args.beliefNodeId
+        ) ?? "",
+        {
+          title: readString(args.title) ?? "",
+          description: readString(args.description),
+          conditionType: readString(args.conditionType),
+          direction: readString(args.direction),
+          condition: asRecord(args.condition),
+          deadline: readNumber(args.deadline),
+          compositeOf: readStringArray(args.compositeOf),
+          compositeOperator: readString(args.compositeOperator),
+          modulation: asRecord(args.modulation),
+          evaluationSchedule: readString(
+            args.evaluationSchedule ?? args.schedule
+          ),
+          periodicIntervalMs: readNumber(args.periodicIntervalMs)
+        }
+      )
+    );
+  },
+  async bisect_confidence(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.bisect(
+        readString(args.id ?? args.nodeId ?? args.beliefId) ?? "",
+        {
+          expectedDirection: readString(args.expectedDirection),
+          timeRange: readTimeRange(args.timeRange)
+        }
+      )
+    );
+  }
+};
+
+// ../../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(components2.lucern.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(components2.lucern.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 track = String(worktree.track || "untracked");
+  const trackPosition = worktree.trackPosition ?? 0;
+  const executionBand = worktree.executionBand ?? 0;
+  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(components2.lucern.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(components2.lucern.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,
+    track,
+    trackPosition,
+    executionBand,
+    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) {
+    return formatSdkResult(
+      await getSdkClient(ctx).bootstrap.generateSessionHandoff(args)
+    );
+  },
+  async begin_build_session(args, ctx) {
+    return beginBuildSession(args);
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/coding.ts
+var codingHandlers = {
+  async get_code_context(args, ctx) {
+    return formatSdkResult(await getSdkClient(ctx).coding.getCodeContext(args));
+  },
+  async get_change_history(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).coding.getChangeHistory(args)
+    );
+  },
+  async record_attempt(args, ctx) {
+    return formatSdkResult(await getSdkClient(ctx).coding.recordAttempt(args));
+  },
+  async get_failure_log(args, ctx) {
+    return formatSdkResult(await getSdkClient(ctx).coding.getFailureLog(args));
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/contracts.ts
+var contractHandlers = {
+  async create_epistemic_contract(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).contracts.create(args)
+    );
+  },
+  async evaluate_contract(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).contracts.evaluate({
+        contractId: readString(args.contractId),
+        trigger: args.trigger,
+        topicId: readString(args.topicId)
+      })
+    );
+  },
+  async get_contract_status(args, ctx) {
+    if (!args.beliefNodeId && !args.contractId) {
+      throw new Error(
+        "get_contract_status requires either beliefNodeId or contractId."
+      );
+    }
+    return formatSdkResult(
+      await getSdkClient(ctx).contracts.getStatus({
+        beliefNodeId: readString(args.beliefNodeId),
+        contractId: readString(args.contractId),
+        status: args.status
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/contradictions.ts
+function normalizeBeliefId(value) {
+  try {
+    const decoded = decodePrefixedId(value);
+    return encodePrefixedId("bel", decoded.value);
+  } catch {
+    return encodePrefixedId("bel", value);
+  }
+}
+var contradictionHandlers = {
+  async flag_contradiction(args, ctx) {
+    const topicId = await resolveTopicScopeId(
+      readTopicIdArg(args),
+      "flag_contradiction"
+    );
+    return formatSdkResult(
+      await getSdkClient(ctx).contradictions.flag({
+        beliefA: readString(args.beliefA) ?? "",
+        beliefB: readString(args.beliefB) ?? "",
+        description: readString(args.description) ?? "",
+        topicId,
+        severity: readString(args.severity),
+        defeatType: readString(args.defeatType)
+      })
+    );
+  },
+  async find_contradictions(args, ctx) {
+    const topicId = await resolveTopicScopeId(
+      readTopicIdArg(args) ?? readString(args.nodeId),
+      "find_contradictions"
+    );
+    const beliefId = readString(args.nodeId);
+    const payload = formatSdkResult(
+      await getSdkClient(ctx).contradictions.list({
+        topicId,
+        status: readString(args.status),
+        limit: readNumber(args.limit)
+      })
+    );
+    if (!beliefId) {
+      return payload;
+    }
+    const normalizedBeliefId = normalizeBeliefId(beliefId);
+    return {
+      ...payload,
+      contradictions: (Array.isArray(payload.contradictions) ? payload.contradictions : []).filter(
+        (entry) => entry.beliefA === normalizedBeliefId || entry.beliefB === normalizedBeliefId
+      )
+    };
+  },
+  async list_contradictions(args, ctx) {
+    const topicId = await resolveTopicScopeId(
+      readTopicIdArg(args),
+      "list_contradictions"
+    );
+    return formatSdkResult(
+      await getSdkClient(ctx).contradictions.list({
+        topicId,
+        status: readString(args.status),
+        limit: readNumber(args.limit)
+      })
+    );
+  },
+  async get_contradiction(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).contradictions.get(
+        readString(args.id ?? args.contradictionId) ?? ""
+      )
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/coordination.ts
+var coordinationHandlers = {
+  async register_session(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).coordination.registerSession(args)
+    );
+  },
+  async heartbeat_session(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).coordination.heartbeatSession(args)
+    );
+  },
+  async end_session(args, ctx) {
+    return formatSdkResult(await getSdkClient(ctx).coordination.endSession(args));
+  },
+  async list_active_sessions(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).coordination.listActiveSessions(args)
+    );
+  },
+  async send_agent_message(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).coordination.sendAgentMessage(args)
+    );
+  },
+  async broadcast_message(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).coordination.broadcastMessage(args)
+    );
+  },
+  async get_agent_inbox(args, ctx) {
+    return formatSdkResult(await getSdkClient(ctx).coordination.getInbox(args));
+  },
+  async claim_files(args, ctx) {
+    return formatSdkResult(await getSdkClient(ctx).coordination.claimFiles(args));
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/edges.ts
+var edgeHandlers = {
+  async create_edge(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).edges.create({
+        sourceId: readString(args.sourceId) ?? "",
+        targetId: readString(args.targetId) ?? "",
+        edgeType: readString(args.edgeType) ?? "",
+        topicId: readString(args.topicId ?? args.projectId),
+        confidence: readNumber(args.confidence),
+        weight: readNumber(args.weight),
+        context: readString(args.context) ?? readString(args.reasoning)
+      })
+    );
+  },
+  async list_edges(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).edges.list({
+        sourceId: readString(args.sourceId) ?? "",
+        edgeType: readString(args.edgeType),
+        limit: readNumber(args.limit),
+        cursor: readString(args.cursor)
+      })
+    );
+  },
+  async traverse_graph(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).edges.traverse({
+        startNode: readString(args.startNode) ?? "",
+        direction: readString(args.direction),
+        maxDepth: readNumber(args.maxDepth),
+        topicId: readString(args.topicId ?? args.projectId)
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/graph.ts
+var graphHandlers = {
+  async traverse_graph(args, ctx) {
+    return edgeHandlers.traverse_graph(args, ctx);
+  },
+  async search_beliefs(args, ctx) {
+    const topicId = await resolveTopicScopeId(
+      readTopicIdArg(args),
+      "search_beliefs"
+    );
+    return formatSdkResult(
+      await getSdkClient(ctx).beliefs.search({
+        query: typeof args.query === "string" ? args.query : "",
+        topicId,
+        status: typeof args.status === "string" ? args.status : void 0,
+        minConfidence: typeof args.minConfidence === "number" ? args.minConfidence : void 0,
+        limit: typeof args.limit === "number" ? args.limit : void 0
+      })
+    );
+  },
+  async find_contradictions(args, ctx) {
+    return contradictionHandlers.find_contradictions(args, ctx);
+  },
+  async bisect_confidence(args, ctx) {
+    return beliefHandlers.bisect_confidence(args, ctx);
+  },
+  async trace_entity_impact(args, ctx) {
+    const topicId = await resolveTopicScopeId(
+      readTopicIdArg(args),
+      "trace_entity_impact"
+    ).catch(() => void 0);
+    return formatSdkResult(
+      await getSdkClient(ctx).graph.traceEntityImpact({
+        nodeId: typeof args.nodeId === "string" ? args.nodeId : "",
+        topicId
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/topics.ts
+var topicHandlers = {
+  async create_topic(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).topics.create({
+        name: readString(args.name) ?? "",
+        description: readString(args.description),
+        type: readString(args.type),
+        parentTopicId: readString(args.parentTopicId),
+        ontologyId: readString(args.ontologyId),
+        tenantId: readString(args.tenantId),
+        workspaceId: readString(args.workspaceId),
+        visibility: readString(args.visibility),
+        createdBy: readString(args.createdBy)
+      })
+    );
+  },
+  async list_topics(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).topics.list({
+        ontologyId: readString(args.ontologyId),
+        parentTopicId: readString(args.parentTopicId),
+        status: readString(args.status),
+        type: readString(args.type)
+      })
+    );
+  },
+  async get_topic(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).topics.get(
+        readString(args.topicId ?? args.id) ?? ""
+      )
+    );
+  },
+  async update_topic(args, ctx) {
+    const topicId = readString(args.topicId ?? args.id) ?? "";
+    if (!topicId) {
+      throw new Error("topicId is required.");
+    }
+    return formatSdkResult(
+      await getSdkClient(ctx).topics.update(topicId, {
+        name: readString(args.name),
+        description: readString(args.description),
+        type: readString(args.type),
+        ontologyId: readString(args.ontologyId),
+        clearOntologyId: readBoolean(args.clearOntologyId),
+        status: readString(args.status),
+        visibility: readString(args.visibility)
+      })
+    );
+  },
+  async get_topic_tree(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).topics.getTree({
+        rootId: readString(args.rootId ?? args.topicId ?? args.id) ?? "",
+        maxDepth: readNumber(args.maxDepth)
+      })
+    );
+  },
+  async get_topic_coverage(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).topics.coverage(
+        readString(args.topicId ?? args.id) ?? "",
+        {
+          includeDescendants: readBoolean(args.includeDescendants),
+          maxDepth: readNumber(args.maxDepth)
+        }
+      )
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/coverage.ts
+var coverageHandlers = {
+  async get_topic_coverage(args, ctx) {
+    return topicHandlers.get_topic_coverage(
+      {
+        topicId: args.topicId ?? args.id,
+        includeDescendants: args.includeDescendants,
+        maxDepth: args.maxDepth
+      },
+      ctx
+    );
+  },
+  async get_graph_gaps(args, ctx) {
+    return graphHandlers.get_graph_gaps(
+      {
+        topicId: args.topicId ?? args.projectId,
+        minConfidence: args.minConfidence
+      },
+      ctx
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/discovery.ts
+var discoveryHandlers = {
+  async discover(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).context.discover({
+        query: readString(args.query) ?? "",
+        topK: readNumber(args.topK),
+        includeNeighborhood: readBoolean(args.includeNeighborhood)
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/engineering-verification.ts
+function hasVerificationPayload(args) {
+  return args.testOutput !== void 0 || args.tscOutput !== void 0 || args.lintOutput !== void 0 || args.sentryData !== void 0;
+}
+var engineeringVerificationHandlers = {
+  async evaluate_engineering_contract(args, ctx) {
+    if (!hasVerificationPayload(args)) {
+      throw new Error(
+        "evaluate_engineering_contract requires at least one verification payload."
+      );
+    }
+    const result = await adminMutation(
+      "epistemicContracts:evaluateEngineeringContracts",
+      {
+        beliefNodeId: args.beliefNodeId,
+        trigger: args.trigger,
+        testOutput: args.testOutput,
+        tscOutput: args.tscOutput,
+        lintOutput: args.lintOutput,
+        sentryData: args.sentryData,
+        authenticatedUserId: ctx.userId
+      }
+    );
+    return result;
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/evidence.ts
+var evidenceHandlers = {
+  async create_evidence(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).evidence.create({
+        topicId: readString(readTopicIdArg(args)) ?? "",
+        text: readString(args.text) ?? "",
+        source: readString(args.source),
+        targetId: readString(args.targetId),
+        weight: readNumber(args.weight),
+        metadata: asJsonObject(args.metadata),
+        title: readString(args.title),
+        content: readString(args.content),
+        contentType: readString(args.contentType),
+        kind: readString(args.kind)
+      })
+    );
+  },
+  async get_evidence(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).evidence.get(
+        readString(args.id ?? args.evidenceId) ?? ""
+      )
+    );
+  },
+  async list_evidence(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).evidence.list({
+        topicId: readString(readTopicIdArg(args)),
+        targetId: readString(args.targetId),
+        limit: readNumber(args.limit),
+        cursor: readString(args.cursor)
+      })
+    );
+  },
+  async link_evidence(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).evidence.link({
+        evidenceId: readString(args.evidenceId) ?? "",
+        targetId: readString(args.targetId ?? args.beliefId ?? args.questionId) ?? "",
+        targetType: readString(args.targetType),
+        weight: readNumber(args.weight ?? args.relevance),
+        rationale: readString(args.rationale)
+      })
+    );
+  },
+  async search_evidence(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).evidence.search({
+        q: readString(args.q ?? args.query) ?? "",
+        topicId: readString(readTopicIdArg(args)),
+        targetId: readString(args.targetId),
+        limit: readNumber(args.limit),
+        cursor: readString(args.cursor)
+      })
+    );
+  },
+  async add_evidence(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).evidence.add({
+        topicId: readString(readTopicIdArg(args)) ?? "",
+        text: readString(args.text ?? args.canonicalText) ?? "",
+        source: readString(args.source ?? args.sourceUrl),
+        targetId: readString(args.targetId ?? args.targetNodeId),
+        weight: readNumber(args.weight),
+        metadata: {
+          ...asRecord(args.metadata),
+          ...readString(args.reasoning) ? { rationale: readString(args.reasoning) } : {}
+        },
+        title: readString(args.title),
+        content: readString(args.content),
+        contentType: readString(args.contentType),
+        kind: readString(args.kind)
+      })
+    );
+  },
+  async link_evidence_to_belief(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).evidence.linkToBelief({
+        evidenceId: readString(args.evidenceId) ?? "",
+        beliefId: readString(args.beliefId) ?? "",
+        weight: readNumber(args.weight) ?? 1,
+        rationale: readString(args.rationale)
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/identity.ts
+var identityHandlers = {
+  async identity_whoami(_args, ctx) {
+    return formatSdkResult(await getSdkClient(ctx).identity.whoami());
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/intelligence.ts
+var intelligenceHandlers = {
+  detect_confirmation_bias: graphHandlers.detect_confirmation_bias,
+  get_graph_structure_analysis: graphHandlers.get_graph_structure_analysis,
+  get_falsification_questions: graphHandlers.get_falsification_questions
+};
+
+// ../../apps/mcp-server/src/handlers/judgments.ts
+var judgmentHandlers = {
+  async record_judgment(args, ctx) {
+    const topicId = await resolveTopicScopeId(
+      readTopicIdArg(args),
+      "record_judgment"
+    );
+    if (topicId === ROOT_TOPIC_ID) {
+      throw new Error(
+        "[record_judgment] Resolved topic is Root \u2014 epistemic nodes must belong to a child topic. Provide a valid topicId for this judgment."
+      );
+    }
+    return formatSdkResult(
+      await getSdkClient(ctx).judgments.record({
+        title: readString(args.title) ?? "",
+        rationale: readString(args.rationale) ?? "",
+        topicId,
+        confidence: readNumber(args.confidence) ?? 0.7,
+        beliefIds: readStringArray(args.beliefIds)
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/lenses.ts
+function readWorkspaceIdArg(args) {
+  return readString(args.workspaceId);
+}
+var lensHandlers = {
+  async create_lens(args, ctx) {
+    const filterCriteria = args.filterCriteria && typeof args.filterCriteria === "object" ? args.filterCriteria : void 0;
+    if (filterCriteria !== void 0) {
+      const validation = validateFilterCriteria(filterCriteria);
+      if (!validation.valid) {
+        throw new Error(
+          `Invalid filterCriteria: ${validation.errors.join("; ")}`
+        );
+      }
+    }
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.createLens({
+        name: readString(args.name) ?? "",
+        topicId: readTopicIdArg(args),
+        workspaceId: readWorkspaceIdArg(args),
+        description: readString(args.description),
+        perspectiveType: readString(args.perspectiveType),
+        promptTemplates: Array.isArray(args.promptTemplates) ? args.promptTemplates : void 0,
+        workflowTemplates: Array.isArray(args.workflowTemplates) ? args.workflowTemplates : void 0,
+        taskTemplates: Array.isArray(args.taskTemplates) ? args.taskTemplates : void 0,
+        questionTemplates: Array.isArray(args.questionTemplates) ? args.questionTemplates : void 0,
+        filterCriteria
+      })
+    );
+  },
+  async list_lenses(args, ctx) {
+    try {
+      return formatSdkResult(
+        await getSdkClient(ctx).worktrees.listLenses({
+          workspaceId: readWorkspaceIdArg(args),
+          topicId: readTopicIdArg(args),
+          status: readString(args.status),
+          perspectiveType: readString(args.perspectiveType)
+        })
+      );
+    } catch (error) {
+      if (error instanceof Error && error.message.includes(
+        "workspaceId is required unless topicId resolves to a workspace-scoped topic"
+      )) {
+        return {
+          lenses: [],
+          note: "workspaceId is required unless topicId resolves to a workspace-scoped topic"
+        };
+      }
+      throw error;
+    }
+  },
+  async apply_lens_to_topic(args, ctx) {
+    const topicId = readTopicIdArg(args);
+    if (!topicId) {
+      throw new Error("topicId is required");
+    }
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.applyLensToTopic({
+        lensId: readString(args.lensId) ?? "",
+        topicId,
+        metadata: args.metadata && typeof args.metadata === "object" ? args.metadata : void 0
+      })
+    );
+  },
+  async remove_lens_from_topic(args, ctx) {
+    const topicId = readTopicIdArg(args);
+    if (!topicId) {
+      throw new Error("topicId is required");
+    }
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.removeLensFromTopic({
+        lensId: readString(args.lensId) ?? "",
+        topicId
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/lineage.ts
+var lineageHandlers = {
+  async query_lineage(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).graph.queryLineage(
+        readString(args.id ?? args.nodeId ?? args.beliefId) ?? ""
+      )
+    );
+  },
+  async get_confidence_history(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).graph.getConfidenceHistory(
+        readString(args.id ?? args.nodeId ?? args.beliefId) ?? ""
+      )
+    );
+  },
+  async get_audit_trail(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).graph.getAuditTrail(
+        args.nodeId,
+        args.limit ?? 50
+      )
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/observations.ts
+var observationStore = /* @__PURE__ */ new Map();
+function tokenize(input) {
+  return input.toLowerCase().split(/[^a-z0-9]+/).map((token) => token.trim()).filter(Boolean);
+}
+function scoreSemanticMatch(record, query) {
+  const queryTokens = new Set(tokenize(query));
+  if (queryTokens.size === 0) {
+    return 0;
+  }
+  const haystack = [record.summary, record.source || "", ...record.tags || []].join(" ").toLowerCase();
+  let score = 0;
+  for (const token of queryTokens) {
+    if (haystack.includes(token)) {
+      score += 1;
+    }
+  }
+  return score;
+}
+var observationHandlers = {
+  async ingest_observation(args, _ctx) {
+    const topicId = await resolveTopicScopeId(
+      readTopicIdArg(args),
+      "ingest_observation"
+    );
+    const observationType = args.observationType;
+    const summary = args.summary;
+    const source = args.source || void 0;
+    const confidence = args.confidence || void 0;
+    const tags = (args.tags || []).filter(
+      (tag) => typeof tag === "string" && tag.trim().length > 0
+    );
+    const metadata = args.metadata || void 0;
+    const createdAt = Date.now();
+    const observationId = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `obs_${createdAt}_${Math.random().toString(36).slice(2)}`;
+    const record = {
+      observationId,
+      topicId,
+      observationType,
+      summary,
+      source,
+      confidence,
+      tags,
+      metadata,
+      createdAt
+    };
+    const existing = observationStore.get(topicId) || [];
+    existing.push(record);
+    observationStore.set(topicId, existing.slice(-500));
+    return {
+      observationId,
+      topicId,
+      observationType,
+      createdAt,
+      contextResourceUri: `lucern://observations/${topicId}`
+    };
+  },
+  async get_observation_context(args, _ctx) {
+    const topicId = await resolveTopicScopeId(
+      readTopicIdArg(args),
+      "get_observation_context"
+    );
+    const query = args.query || "";
+    const limit = Math.max(1, Math.min(args.limit || 25, 200));
+    const records = observationStore.get(topicId) || [];
+    const latest = records.slice(-limit).reverse();
+    const semanticMatches = query ? records.map((record) => ({
+      record,
+      score: scoreSemanticMatch(record, query)
+    })).filter((row) => row.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((row) => row.record) : [];
+    const byType = {};
+    for (const row of records) {
+      byType[row.observationType] = (byType[row.observationType] || 0) + 1;
+    }
+    return {
+      topicId,
+      totalObservations: records.length,
+      latest,
+      semanticMatches,
+      byType,
+      generatedAt: Date.now()
+    };
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/ontologies.ts
+var ontologyHandlers = {
+  async list_ontologies(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.list({
+        tenantId: readString(args.tenantId),
+        tier: readString(args.tier),
+        status: readString(args.status)
+      })
+    );
+  },
+  async get_ontology(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.get({
+        id: readString(args.id ?? args.ontologyId),
+        ontologyKey: readString(args.ontologyKey),
+        tenantId: readString(args.tenantId),
+        tier: readString(args.tier),
+        status: readString(args.status)
+      })
+    );
+  },
+  async apply_ontology(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.bind({
+        ontologyId: readString(args.ontologyId ?? args.id) ?? "",
+        topicId: readString(args.topicId) ?? ""
+      })
+    );
+  },
+  async match_entity_type(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.match({
+        text: readString(args.text) ?? "",
+        topicId: readString(args.topicId),
+        ontologyId: readString(args.ontologyId),
+        minScore: readNumber(args.minScore),
+        limit: readNumber(args.limit)
+      })
+    );
+  },
+  async create_ontology(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.create({
+        ontologyKey: readString(args.ontologyKey) ?? "",
+        name: readString(args.name) ?? "",
+        description: readString(args.description),
+        tenantId: readString(args.tenantId),
+        tier: readString(args.tier) ?? "platform",
+        parentOntologyId: readString(args.parentOntologyId)
+      })
+    );
+  },
+  async update_ontology(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.update({
+        id: readString(args.id) ?? "",
+        name: readString(args.name),
+        description: readString(args.description),
+        status: readString(args.status)
+      })
+    );
+  },
+  async archive_ontology(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.archive({
+        id: readString(args.id) ?? ""
+      })
+    );
+  },
+  async create_ontology_version(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.createVersion({
+        ontologyId: readString(args.ontologyId) ?? "",
+        version: readString(args.version) ?? "",
+        entityTypes: Array.isArray(args.entityTypes) ? args.entityTypes : [],
+        edgeTypes: Array.isArray(args.edgeTypes) ? args.edgeTypes : [],
+        releaseNotes: readString(args.releaseNotes)
+      })
+    );
+  },
+  async publish_ontology_version(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.publishVersion({
+        id: readString(args.id) ?? ""
+      })
+    );
+  },
+  async deprecate_ontology_version(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.deprecateVersion({
+        id: readString(args.id) ?? ""
+      })
+    );
+  },
+  async resolve_effective_ontology(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).ontologies.resolveEffective({
+        ontologyId: readString(args.ontologyId) ?? ""
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/ontology-matching.ts
+var ontologyMatchingHandlers = {
+  async match_entity_type(args, ctx) {
+    return ontologyHandlers.match_entity_type(args, ctx);
+  },
+  async discover_entity_connections(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).context.discoverEntityConnections({
+        nodeId: readString(args.nodeId) ?? "",
+        topicId: readString(args.topicId),
+        minScore: readNumber(args.minScore),
+        limit: readNumber(args.limit)
+      })
+    );
+  },
+  async trigger_belief_review(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).context.triggerBeliefReview({
+        entityNodeId: readString(args.entityNodeId) ?? "",
+        changeDescription: readString(args.changeDescription),
+        maxQuestions: readNumber(args.maxQuestions)
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/policy.ts
+var policyHandlers = {
+  async check_permission(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).policy.checkPermission(args)
+    );
+  },
+  async filter_by_permission(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).policy.filterByPermission(args)
+    );
+  },
+  async manage_write_policy(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).policy.manageWritePolicy(args)
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/questions.ts
+var questionHandlers = {
+  async create_question(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).questions.create({
+        topicId: readString(args.topicId) ?? "",
+        text: readString(args.text) ?? "",
+        priority: readString(args.priority),
+        linkedBeliefId: readString(args.linkedBeliefId),
+        metadata: asRecord(args.metadata)
+      })
+    );
+  },
+  async get_question(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).questions.get(
+        readString(args.id ?? args.questionId) ?? ""
+      )
+    );
+  },
+  async list_questions(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).questions.list({
+        topicId: readString(args.topicId),
+        status: readString(args.status),
+        priority: readString(args.priority),
+        worktreeId: readString(args.worktreeId),
+        limit: readNumber(args.limit),
+        cursor: readString(args.cursor)
+      })
+    );
+  },
+  async answer_question(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).questions.answer(
+        readString(args.id ?? args.questionId) ?? "",
+        {
+          text: readString(args.text) ?? "",
+          confidence: readString(args.confidence),
+          evidenceIds: readStringArray(args.evidenceIds),
+          rationale: readString(args.rationale)
+        }
+      )
+    );
+  },
+  async refine_question(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).questions.refine(
+        readString(args.id ?? args.questionId) ?? "",
+        readString(args.text) ?? "",
+        readString(args.rationale ?? args.refinementReason)
+      )
+    );
+  },
+  async update_question_status(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).questions.updateStatus(
+        readString(args.id ?? args.questionId) ?? "",
+        readString(args.status) ?? "",
+        readString(args.rationale)
+      )
+    );
+  },
+  async archive_question(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).questions.archive(
+        readString(args.id ?? args.questionId) ?? "",
+        readString(args.reason ?? args.rationale)
+      )
+    );
+  },
+  async link_evidence_to_question(args, ctx) {
+    const result = await evidenceHandlers.link_evidence(
+      {
+        evidenceId: readString(args.evidenceId) ?? "",
+        targetId: readString(args.questionId) ?? "",
+        weight: readNumber(args.relevance),
+        rationale: readString(args.rationale)
+      },
+      ctx
+    );
+    return {
+      ...result,
+      questionId: readString(args.questionId) ?? result.targetId,
+      relevance: readNumber(args.relevance)
+    };
+  },
+  async get_high_priority_questions(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).questions.getHighPriority({
+        topicId: readString(args.topicId),
+        limit: readNumber(args.limit),
+        includeAnswered: readBoolean(args.includeAnswered)
+      })
+    );
+  },
+  async find_missing_questions(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).questions.findMissing({
+        topicId: readString(args.topicId) ?? "",
+        minConfidence: readNumber(args.minConfidence)
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/research.ts
+var researchHandlers = {
+  async search_sources(args, ctx) {
+    return formatSdkResult(await getSdkClient(ctx).research.searchSources(args));
+  },
+  async execute_deep_research(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).research.executeDeepResearch(args)
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/research-verification.ts
+function buildInputData(args) {
+  const entries = Object.entries({
+    metricData: args.metricData,
+    referenceCheckData: args.referenceCheckData,
+    marketIndexData: args.marketIndexData,
+    temporalData: args.temporalData
+  }).filter(([, value]) => value !== void 0);
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+var researchVerificationHandlers = {
+  async evaluate_research_contract(args, ctx) {
+    const inputData = buildInputData(args);
+    const result = await adminMutation(
+      api2.epistemicContracts.evaluateContractsForTrigger,
+      {
+        beliefNodeId: args.beliefNodeId,
+        trigger: typeof args.trigger === "string" && args.trigger.length > 0 ? args.trigger : "event_driven",
+        ...inputData ? { inputData } : {},
+        authenticatedUserId: ctx.userId
+      }
+    );
+    return result;
+  }
+};
+
+// ../server-core/src/domain/context/compile.ts
+function cleanString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function prefixId(prefix, value) {
+  const cleaned = cleanString(value);
+  if (!cleaned) {
+    return `${prefix}_unknown`;
+  }
+  try {
+    const decoded = decodePrefixedId(cleaned);
+    if (decoded.prefix === prefix) {
+      return cleaned;
+    }
+  } catch {
+  }
+  return encodePrefixedId(prefix, cleaned);
+}
+function mapSelectedIds(value) {
+  return {
+    invariants: (value.invariants ?? []).map((id) => prefixId("bel", id)),
+    activeBeliefs: (value.activeBeliefs ?? []).map((id) => prefixId("bel", id)),
+    openQuestions: (value.openQuestions ?? []).map((id) => prefixId("que", id)),
+    recentEvidence: (value.recentEvidence ?? []).map((id) => prefixId("evi", id)),
+    contradictions: (value.contradictions ?? []).map((id) => prefixId("con", id))
+  };
+}
+function mapExcludedId(section, id) {
+  if (section === "invariants" || section === "activeBeliefs") {
+    return prefixId("bel", id);
+  }
+  if (section === "openQuestions") {
+    return prefixId("que", id);
+  }
+  if (section === "recentEvidence") {
+    return prefixId("evi", id);
+  }
+  if (section === "contradictions") {
+    return prefixId("con", id);
+  }
+  return id;
+}
+function toPublicCompiledContext(pack) {
+  return {
+    schemaVersion: pack.schemaVersion,
+    topicId: prefixId("top", pack.topicId),
+    topicName: pack.topicName,
+    scopedTopicIds: (pack.scopedTopicIds ?? []).map((id) => prefixId("top", id)),
+    generatedAt: pack.generatedAt,
+    ranking: pack.rankingProfile,
+    summary: pack.summary,
+    invariants: (pack.invariants ?? []).map((belief) => ({
+      beliefId: prefixId("bel", belief.nodeId),
+      text: belief.canonicalText,
+      confidence: belief.confidence ?? null,
+      beliefType: belief.beliefType ?? null,
+      score: belief.score,
+      ...belief.justification ? { justification: belief.justification } : {}
+    })),
+    activeBeliefs: (pack.activeBeliefs ?? []).map((belief) => ({
+      beliefId: prefixId("bel", belief.nodeId),
+      text: belief.canonicalText,
+      confidence: belief.confidence ?? null,
+      beliefType: belief.beliefType ?? null,
+      status: belief.status,
+      updatedAt: belief.updatedAt ?? null,
+      score: belief.score,
+      ...belief.justification ? { justification: belief.justification } : {}
+    })),
+    openQuestions: (pack.openQuestions ?? []).map((question) => ({
+      questionId: prefixId("que", question.questionId),
+      text: question.text,
+      status: question.status,
+      priority: question.priority,
+      updatedAt: question.updatedAt ?? null,
+      score: question.score,
+      ...question.justification ? { justification: question.justification } : {}
+    })),
+    recentEvidence: (pack.recentEvidence ?? []).map((evidence) => ({
+      evidenceId: prefixId("evi", evidence.nodeId),
+      text: evidence.canonicalText,
+      kind: evidence.kind,
+      sourceUrl: evidence.sourceUrl ?? null,
+      createdAt: evidence.createdAt ?? null,
+      score: evidence.score,
+      ...evidence.justification ? { justification: evidence.justification } : {}
+    })),
+    contradictions: (pack.contradictions ?? []).map((contradiction) => ({
+      contradictionId: prefixId("con", contradiction.contradictionId),
+      severity: contradiction.severity,
+      status: contradiction.status,
+      description: contradiction.description,
+      score: contradiction.score,
+      ...contradiction.justification ? { justification: contradiction.justification } : {}
+    })),
+    ...pack.relatedEntities ? {
+      relatedEntities: pack.relatedEntities.map((entity) => ({
+        entityId: cleanString(entity.nodeId) ?? "",
+        entityType: entity.entityType,
+        title: entity.title,
+        text: cleanString(entity.canonicalText),
+        connectedBeliefCount: entity.connectedBeliefCount,
+        connectedEvidenceCount: entity.connectedEvidenceCount,
+        score: entity.score,
+        ...entity.metadata ? { metadata: entity.metadata } : {}
+      }))
+    } : {},
+    contextNarrative: pack.contextNarrative ?? [],
+    injectionPolicy: {
+      tokenBudget: pack.injectionPolicy.tokenBudget,
+      estimatedTokens: pack.injectionPolicy.estimatedTokens,
+      sectionBudgets: pack.injectionPolicy.sectionBudgets,
+      sectionUsage: pack.injectionPolicy.sectionUsage,
+      selected: mapSelectedIds(pack.injectionPolicy.selected),
+      ...pack.injectionPolicy.excludedItems ? {
+        excludedItems: pack.injectionPolicy.excludedItems.map((item) => ({
+          ...item,
+          id: mapExcludedId(item.section, item.id)
+        }))
+      } : {}
+    },
+    diagnostics: pack.diagnostics,
+    ...pack.compilationMode ? { compilationMode: pack.compilationMode } : {},
+    ...pack.failureContext ? {
+      failureContext: {
+        failures: pack.failureContext.failures.map((failure) => ({
+          ...failure,
+          attemptId: prefixId("evi", failure.attemptId)
+        })),
+        suppressedIds: pack.failureContext.suppressedIds.map(
+          (id) => prefixId("evi", id)
+        )
+      }
+    } : {},
+    ...pack.deltaReport ? {
+      deltaReport: {
+        changedItems: pack.deltaReport.changedItems.map((item) => ({
+          ...item,
+          id: mapExcludedId(item.section, item.id)
+        })),
+        verificationObligations: pack.deltaReport.verificationObligations,
+        referencePoint: prefixId("wt", pack.deltaReport.referencePoint)
+      }
+    } : {},
+    ...pack.appliedWeightOverrides ? { appliedWeightOverrides: pack.appliedWeightOverrides } : {}
+  };
+}
+
+// ../../apps/mcp-server/src/handlers/scope-context.ts
+var scopeContextHandlers = {
+  async compile_context(args, ctx) {
+    const requestedScope = readTopicIdArg(args);
+    if (!requestedScope) {
+      throw new Error("[compile_context] topicId is required.");
+    }
+    const topicId = await resolveTopicScopeId(requestedScope, "compile_context");
+    if (ctx.sessionType === "user" && Array.isArray(ctx.allowedTopics) && (!ctx.allowedTopics.includes(topicId) || ctx.allowedTopics.length === 0)) {
+      throw new Error(
+        `[compile_context] Access denied to compile context for topic ${topicId}.`
+      );
+    }
+    const compiled = formatSdkResult(
+      await getSdkClient(ctx).context.compile(topicId, {
+        query: readString(args.query),
+        budget: readNumber(args.budget ?? args.tokenBudget),
+        ranking: readString(args.ranking ?? args.rankingProfile),
+        limit: readNumber(args.limit),
+        maxDepth: readNumber(args.maxDepth),
+        includeEntities: readBoolean(args.includeEntities),
+        mode: readString(args.mode),
+        includeFailures: readBoolean(args.includeFailures),
+        worktreeId: readString(args.worktreeId),
+        sessionId: readString(args.sessionId),
+        packWeightOverrides: Array.isArray(args.packWeightOverrides) ? args.packWeightOverrides : void 0
+      })
+    );
+    return toPublicCompiledContext(compiled);
+  },
+  async record_scope_learning(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).context.recordScopeLearning(args)
+    );
+  },
+  async seed_belief_lattice(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).context.seedBeliefLattice(args)
+    );
+  },
+  async get_lattice_coverage(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).context.getLatticeCoverage(args)
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/search.ts
+var searchHandlers = {
+  async search_resources(args, ctx) {
+    const topicId = readString(args.topicId) ?? readString(args.projectId) ?? "";
+    if (!topicId) {
+      throw new Error("search_resources requires a topicId parameter");
+    }
+    return formatSdkResult(
+      await getSdkClient(ctx).search(readString(args.q) ?? readString(args.query) ?? "", {
+        topicId,
+        types: readStringArray(args.types),
+        status: readString(args.status),
+        minConfidence: readNumber(args.minConfidence),
+        limit: readNumber(args.limit),
+        cursor: readString(args.cursor)
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/tasks.ts
+var taskHandlers = {
+  async create_task(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).tasks.create({
+        topicId: readString(args.topicId ?? args.projectId) ?? "",
+        title: readString(args.title) ?? "",
+        description: readString(args.description),
+        taskType: readString(args.taskType),
+        priority: readString(args.priority),
+        linkedBeliefId: readString(args.linkedBeliefId),
+        linkedQuestionId: readString(args.linkedQuestionId),
+        linkedWorktreeId: readString(args.linkedWorktreeId)
+      })
+    );
+  },
+  async complete_task(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).tasks.complete(
+        readString(args.taskId ?? args.id) ?? "",
+        {
+          outputSummary: readString(args.outputSummary) ?? ""
+        }
+      )
+    );
+  },
+  async update_task(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).tasks.update(
+        readString(args.taskId ?? args.id) ?? "",
+        {
+          title: readString(args.title),
+          description: readString(args.description),
+          priority: readString(args.priority),
+          status: readString(args.status),
+          linkedBeliefId: readString(args.linkedBeliefId),
+          linkedQuestionId: readString(args.linkedQuestionId),
+          linkedWorktreeId: readString(args.linkedWorktreeId)
+        }
+      )
+    );
+  },
+  async list_tasks(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).tasks.list({
+        topicId: readString(args.topicId ?? args.projectId),
+        worktreeId: readString(args.worktreeId) ?? readString(args.linkedWorktreeId),
+        status: readString(args.status),
+        limit: readNumber(args.limit)
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/thesis-artifacts.ts
+function stripHtml(value) {
+  return value.replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/\s+/g, " ").trim();
+}
+function truncateText(value, maxChars = 320) {
+  if (!value) {
+    return null;
+  }
+  if (value.length <= maxChars) {
+    return value;
+  }
+  return `${value.slice(0, maxChars - 3).trimEnd()}...`;
+}
+function normalizeThesis(worktree) {
+  const thesis = worktree.branchThesis && typeof worktree.branchThesis === "object" ? worktree.branchThesis : worktree.pillarThesis && typeof worktree.pillarThesis === "object" ? worktree.pillarThesis : null;
+  return thesis ?? null;
+}
+function hasThesisArtifact(worktree) {
+  const thesis = normalizeThesis(worktree);
+  return Boolean(
+    typeof thesis?.content === "string" && thesis.content.trim().length > 0
+  );
+}
+function normalizeWorktreeId(worktree) {
+  if (typeof worktree.worktreeId === "string") {
+    return worktree.worktreeId;
+  }
+  if (typeof worktree._id === "string") {
+    return worktree._id;
+  }
+  return null;
+}
+function normalizeTopicId(worktree) {
+  return typeof worktree.topicId === "string" ? worktree.topicId : null;
+}
+function rankWorktreesByArtifact(left, right) {
+  const leftThesis = normalizeThesis(left);
+  const rightThesis = normalizeThesis(right);
+  const leftRank = leftThesis?.status === "final" || typeof leftThesis?.approvedAt === "number" ? 2 : 1;
+  const rightRank = rightThesis?.status === "final" || typeof rightThesis?.approvedAt === "number" ? 2 : 1;
+  if (leftRank !== rightRank) {
+    return rightRank - leftRank;
+  }
+  const leftTimestamp = leftThesis?.approvedAt ?? leftThesis?.generatedAt ?? left.updatedAt ?? left.createdAt ?? left._creationTime ?? 0;
+  const rightTimestamp = rightThesis?.approvedAt ?? rightThesis?.generatedAt ?? right.updatedAt ?? right.createdAt ?? right._creationTime ?? 0;
+  return rightTimestamp - leftTimestamp;
+}
+function summarizeQuestionPayload(questions) {
+  const normalized = Array.isArray(questions) ? questions : [];
+  const answered = normalized.filter((question) => {
+    const status = question && typeof question === "object" && "status" in question ? String(question.status ?? "").toLowerCase() : "";
+    return status === "answered" || status === "final";
+  }).length;
+  const open = normalized.filter((question) => {
+    const status = question && typeof question === "object" && "status" in question ? String(question.status ?? "").toLowerCase() : "";
+    return status === "open" || status === "in_progress" || status === "active";
+  }).length;
+  return {
+    total: normalized.length,
+    answered,
+    open
+  };
+}
+async function buildWorktreeArtifact(args) {
+  const worktreeId = normalizeWorktreeId(args.worktree);
+  if (!worktreeId) {
+    return null;
+  }
+  const thesis = normalizeThesis(args.worktree);
+  const thesisHtml = typeof thesis?.content === "string" && thesis.content.trim().length > 0 ? thesis.content : null;
+  const memoHtml = typeof thesis?.memoContent === "string" && thesis.memoContent.trim().length > 0 ? thesis.memoContent : null;
+  const thesisText = thesisHtml ? stripHtml(thesisHtml) : null;
+  const memoText = memoHtml ? stripHtml(memoHtml) : null;
+  const [beliefs, qa, recentEvidence, openQuestions, versionHistory] = await Promise.all([
+    adminQuery(components2.lucern.epistemicBeliefs.getByWorktree, {
+      worktreeId
+    }).catch(() => []),
+    args.topicId ? adminQuery(api2.worktrees.getWorktreeQAForReport, {
+      worktreeId,
+      topicId: args.topicId,
+      userId: args.userId
+    }).catch(() => null) : Promise.resolve(null),
+    args.topicId ? adminQuery(components2.lucern.epistemicEvidence.getByTopic, {
+      topicId: args.topicId,
+      userId: args.userId,
+      limit: 8
+    }).catch(() => []) : Promise.resolve([]),
+    args.topicId ? adminQuery(components2.lucern.epistemicQuestions.getByTopic, {
+      topicId: args.topicId,
+      userId: args.userId,
+      limit: 8,
+      status: "open"
+    }).catch(() => []) : Promise.resolve([]),
+    args.includeVersions ? adminQuery(api2.worktrees.getPillarThesisVersions, {
+      worktreeId
+    }).catch(() => []) : Promise.resolve([])
+  ]);
+  const supportingBeliefs = (Array.isArray(beliefs) ? beliefs : []).slice().sort((left, right) => {
+    const leftConfidence = typeof left?.confidence === "number" ? left.confidence : typeof left?.currentConfidence === "number" ? left.currentConfidence : 0;
+    const rightConfidence = typeof right?.confidence === "number" ? right.confidence : typeof right?.currentConfidence === "number" ? right.currentConfidence : 0;
+    return rightConfidence - leftConfidence;
+  }).slice(0, 8).map((belief) => ({
+    nodeId: String(belief?._id ?? belief?.nodeId ?? ""),
+    canonicalText: String(
+      belief?.canonicalText ?? belief?.text ?? belief?.title ?? ""
+    ),
+    confidence: typeof belief?.confidence === "number" ? belief.confidence : typeof belief?.currentConfidence === "number" ? belief.currentConfidence : null,
+    status: belief?.status ?? null,
+    criticality: belief?.criticality ?? belief?.metadata?.criticality ?? null
+  }));
+  const reportQuestions = Array.isArray(qa?.questions) ? qa.questions : Array.isArray(openQuestions) ? openQuestions : [];
+  return {
+    artifactState: thesisHtml || memoHtml ? "ready" : "missing",
+    worktreeId,
+    worktreeName: typeof args.worktree.name === "string" ? args.worktree.name : typeof args.worktree.title === "string" ? args.worktree.title : "Untitled worktree",
+    topicId: args.topicId,
+    topicName: args.topicName,
+    status: args.worktree.status ?? null,
+    phase: args.worktree.phase ?? null,
+    track: args.worktree.track ?? null,
+    executionBand: typeof args.worktree.executionBand === "number" ? args.worktree.executionBand : null,
+    hypothesis: typeof args.worktree.hypothesis === "string" ? args.worktree.hypothesis : null,
+    thesisStatus: thesis?.status ?? null,
+    generatedAt: typeof thesis?.generatedAt === "number" ? thesis.generatedAt : null,
+    approvedAt: typeof thesis?.approvedAt === "number" ? thesis.approvedAt : null,
+    thesisHtml,
+    thesisText,
+    memoHtml,
+    memoText,
+    preferredArtifact: memoText && memoText.length > 0 ? { format: "text", text: memoText, source: "memo" } : thesisText && thesisText.length > 0 ? { format: "text", text: thesisText, source: "thesis" } : null,
+    preview: truncateText(memoText) ?? truncateText(thesisText) ?? truncateText(
+      typeof args.worktree.hypothesis === "string" ? args.worktree.hypothesis : null
+    ),
+    questionSummary: summarizeQuestionPayload(reportQuestions),
+    supportingBeliefs,
+    openQuestions: reportQuestions.slice(0, 8).map((question) => ({
+      questionId: String(question?.questionId ?? question?._id ?? ""),
+      question: String(question?.question ?? question?.canonicalText ?? ""),
+      status: question?.status ?? null,
+      importance: typeof question?.importance === "number" ? question.importance : null,
+      answer: typeof question?.answer === "string" && question.answer.trim().length > 0 ? question.answer : null
+    })),
+    recentEvidence: (Array.isArray(recentEvidence) ? recentEvidence : []).slice(0, 6).map((evidence) => ({
+      nodeId: String(evidence?._id ?? evidence?.nodeId ?? ""),
+      title: String(evidence?.title ?? evidence?.canonicalText ?? ""),
+      canonicalText: String(evidence?.canonicalText ?? evidence?.text ?? ""),
+      sourceUrl: typeof evidence?.sourceUrl === "string" ? evidence.sourceUrl : null
+    })),
+    versionHistory: Array.isArray(versionHistory) ? versionHistory.map((version) => ({
+      version: typeof version?.version === "number" ? version.version : null,
+      status: version?.status ?? null,
+      changeType: version?.changeType ?? null,
+      changeDescription: version?.changeDescription ?? null,
+      createdAt: typeof version?.createdAt === "number" ? version.createdAt : null
+    })) : []
+  };
+}
+var thesisArtifactHandlers = {
+  async get_thesis_artifacts(args, ctx) {
+    const defaultTopicId2 = getDefaultScopeContext().topicId ?? void 0;
+    const requestedTopicId = readTopicIdArg(args) || defaultTopicId2 || void 0;
+    const worktreeId = typeof args.worktreeId === "string" && args.worktreeId.trim().length > 0 ? args.worktreeId.trim() : void 0;
+    const includeVersions = args.includeVersions === true;
+    const limit = typeof args.limit === "number" && Number.isFinite(args.limit) ? Math.max(1, Math.min(10, Math.floor(args.limit))) : 5;
+    let selectedWorktree = null;
+    if (worktreeId) {
+      selectedWorktree = await adminQuery(components2.lucern.worktrees.get, {
+        worktreeId
+      }).catch(() => null);
+    }
+    const resolvedTopicId = requestedTopicId || normalizeTopicId(selectedWorktree ?? {}) || null;
+    let topicName = null;
+    if (resolvedTopicId) {
+      const topic = await adminQuery(components2.lucern.topics.get, {
+        id: resolvedTopicId
+      }).catch(() => null);
+      topicName = typeof topic?.name === "string" ? topic.name : null;
+    }
+    const topicWorktrees = resolvedTopicId ? await adminQuery(components2.lucern.worktrees.getByTopic, {
+      topicId: resolvedTopicId
+    }).catch(() => []) : [];
+    const rankedTopicArtifacts = topicWorktrees.filter(hasThesisArtifact).sort(rankWorktreesByArtifact);
+    const selectedArtifact = selectedWorktree ? await buildWorktreeArtifact({
+      worktree: selectedWorktree,
+      topicId: resolvedTopicId,
+      topicName,
+      userId: ctx.userId,
+      includeVersions
+    }) : rankedTopicArtifacts.length > 0 ? await buildWorktreeArtifact({
+      worktree: rankedTopicArtifacts[0],
+      topicId: resolvedTopicId,
+      topicName,
+      userId: ctx.userId,
+      includeVersions
+    }) : null;
+    const topicArtifacts = await Promise.all(
+      rankedTopicArtifacts.slice(0, limit).map(
+        (worktree) => buildWorktreeArtifact({
+          worktree,
+          topicId: resolvedTopicId,
+          topicName,
+          userId: ctx.userId,
+          includeVersions: false
+        })
+      )
+    );
+    return {
+      scope: {
+        topicId: resolvedTopicId,
+        topicName,
+        worktreeId: worktreeId ?? null
+      },
+      selectedArtifact,
+      topicArtifacts: topicArtifacts.filter(Boolean),
+      availableArtifactCount: rankedTopicArtifacts.length,
+      recommendedUses: [
+        "Draft a meeting agenda grounded in the latest worktree thesis and open questions.",
+        "Turn the memo text into a one-pager, partner update, or investment note.",
+        "Use the thesis plus supporting beliefs as slide-outline raw material for a deck.",
+        "Seed blog-post or email drafts from the narrative artifact without re-querying the graph."
+      ]
+    };
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/worktrees.ts
+var worktreeHandlers = {
+  async add_worktree(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.add({
+        title: readString(args.title) ?? "",
+        topicId: readString(args.topicId ?? args.projectId) ?? "",
+        objective: readString(args.objective),
+        hypothesis: readString(args.hypothesis),
+        beliefIds: readStringArray(args.beliefIds) ?? readStringArray(args.beliefs),
+        autoShape: typeof args.autoShape === "boolean" ? args.autoShape : void 0,
+        domainPackId: readString(args.domainPackId),
+        executionOrder: readNumber(args.executionOrder),
+        dependsOn: readStringArray(args.dependsOn),
+        blocks: readStringArray(args.blocks),
+        gate: readString(args.gate),
+        proofArtifacts: Array.isArray(args.proofArtifacts) ? args.proofArtifacts : void 0,
+        staffingHint: readString(args.staffingHint),
+        lastReconciledAt: readNumber(args.lastReconciledAt),
+        autoFixPolicy: args.autoFixPolicy && typeof args.autoFixPolicy === "object" && !Array.isArray(args.autoFixPolicy) ? args.autoFixPolicy : void 0
+      })
+    );
+  },
+  async list_worktrees(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.list({
+        topicId: readString(args.topicId ?? args.projectId) ?? "",
+        status: readString(args.status),
+        limit: readNumber(args.limit)
+      })
+    );
+  },
+  async activate_worktree(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.activate(
+        readString(args.worktreeId ?? args.id) ?? ""
+      )
+    );
+  },
+  async update_worktree_metadata(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.updateMetadata({
+        worktreeId: readString(args.worktreeId ?? args.id) ?? "",
+        objective: readString(args.objective),
+        hypothesis: readString(args.hypothesis),
+        rationale: readString(args.rationale),
+        track: readString(args.track),
+        trackPosition: readNumber(args.trackPosition),
+        executionBand: readNumber(args.executionBand),
+        executionOrder: readNumber(args.executionOrder),
+        dependsOn: readStringArray(args.dependsOn),
+        blocks: readStringArray(args.blocks),
+        gate: readString(args.gate),
+        status: readString(args.status),
+        topicId: readString(args.topicId),
+        additionalTopicIds: readStringArray(args.additionalTopicIds),
+        proofArtifacts: Array.isArray(args.proofArtifacts) ? args.proofArtifacts : void 0,
+        staffingHint: readString(args.staffingHint),
+        lastReconciledAt: readNumber(args.lastReconciledAt),
+        autoFixPolicy: args.autoFixPolicy && typeof args.autoFixPolicy === "object" && !Array.isArray(args.autoFixPolicy) ? args.autoFixPolicy : void 0
+      })
+    );
+  },
+  async merge(args, ctx) {
+    const record = asRecord(args);
+    const outcomes = Array.isArray(record.outcomes) ? record.outcomes : [];
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.merge(
+        readString(record.worktreeId ?? record.id) ?? "",
+        {
+          summary: readString(record.summary),
+          outcomes: outcomes.map((entry) => {
+            const row = asRecord(entry);
+            return {
+              beliefId: readString(row.beliefId) ?? "",
+              confidence: readNumber(row.confidence) ?? Number.NaN,
+              rationale: readString(row.rationale) ?? ""
+            };
+          })
+        }
+      )
+    );
+  },
+  async list_all_worktrees(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.listAll({
+        status: readString(args.status),
+        track: readString(args.track),
+        executionBand: readNumber(args.executionBand),
+        limit: readNumber(args.limit)
+      })
+    );
+  },
+  async pipeline_snapshot(args, ctx) {
+    const topicId = readString(args.topicId) ?? "";
+    if (!topicId) {
+      return { error: "topicId is required" };
+    }
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.pipelineSnapshot(topicId)
+    );
+  },
+  async push(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.push(
+        readString(args.worktreeId ?? args.id) ?? "",
+        {
+          targetContext: readString(args.targetContext) ?? "",
+          beliefIds: readStringArray(args.beliefIds)
+        }
+      )
+    );
+  },
+  async open_pull_request(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.openPullRequest(
+        readString(args.worktreeId ?? args.id) ?? "",
+        {
+          summary: readString(args.summary) ?? "",
+          reviewers: readStringArray(args.reviewers)
+        }
+      )
+    );
+  },
+  async update_worktree_targets(args, ctx) {
+    return formatSdkResult(
+      await getSdkClient(ctx).worktrees.updateTargets({
+        worktreeId: readString(args.worktreeId ?? args.id) ?? "",
+        addBeliefIds: readStringArray(args.addBeliefIds),
+        addQuestionIds: readStringArray(args.addQuestionIds),
+        removeBeliefIds: readStringArray(args.removeBeliefIds),
+        removeQuestionIds: readStringArray(args.removeQuestionIds)
+      })
+    );
+  }
+};
+
+// ../../apps/mcp-server/src/handlers/index.ts
+function buildHandlerMap() {
+  return {
+    ...evidenceHandlers,
+    ...questionHandlers,
+    ...searchHandlers,
+    ...answerHandlers,
+    ...worktreeHandlers,
+    ...lensHandlers,
+    ...edgeHandlers,
+    ...judgmentHandlers,
+    ...graphHandlers,
+    ...identityHandlers,
+    ...lineageHandlers,
+    ...intelligenceHandlers,
+    ...researchHandlers,
+    ...researchVerificationHandlers,
+    ...taskHandlers,
+    ...topicHandlers,
+    ...contradictionHandlers,
+    ...contractHandlers,
+    ...engineeringVerificationHandlers,
+    ...policyHandlers,
+    ...observationHandlers,
+    ...scopeContextHandlers,
+    ...codingHandlers,
+    ...coordinationHandlers,
+    ...coverageHandlers,
+    ...discoveryHandlers,
+    ...thesisArtifactHandlers,
+    ...bootstrapHandlers,
+    ...autoBranchingHandlers,
+    ...ontologyHandlers,
+    ...ontologyMatchingHandlers,
+    ...beliefHandlers
+  };
+}
+
+// ../../apps/mcp-server/src/write-policy.ts
+var MUTATION_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "create_belief",
+  "refine_belief",
+  "modulate_confidence",
+  "fork_belief",
+  "archive_belief",
+  "create_evidence",
+  "link_evidence",
+  "add_evidence",
+  "link_evidence_to_belief",
+  "record_scope_learning",
+  "record_attempt",
+  "create_question",
+  "answer_question",
+  "refine_question",
+  "update_question_status",
+  "archive_question",
+  "link_evidence_to_question",
+  "create_answer",
+  "create_edge",
+  "flag_contradiction",
+  "add_worktree",
+  "merge",
+  "activate_worktree",
+  "update_worktree_metadata",
+  "update_worktree_targets",
+  "create_lens",
+  "apply_lens_to_topic",
+  "remove_lens_from_topic",
+  "create_task",
+  "complete_task",
+  "record_judgment",
+  "register_session",
+  "heartbeat_session",
+  "end_session",
+  "send_agent_message",
+  "broadcast_message",
+  "claim_files",
+  "create_topic",
+  "open_pull_request",
+  "apply_auto_branching",
+  "seed_belief_lattice",
+  "trigger_belief_review",
+  "create_epistemic_contract",
+  "evaluate_contract",
+  "create_ontology",
+  "update_ontology",
+  "archive_ontology",
+  "create_ontology_version",
+  "publish_ontology_version",
+  "deprecate_ontology_version",
+  "manage_write_policy"
+]);
+function isMutationTool(toolName) {
+  return MUTATION_TOOL_NAMES.has(toolName);
+}
+var sessionWritesBySession = /* @__PURE__ */ new Map();
+function recordWrite(toolName, topicId, sessionId = "default") {
+  const record = {
+    toolName,
+    timestamp: Date.now(),
+    topicId
+  };
+  const existing = sessionWritesBySession.get(sessionId) ?? [];
+  existing.push(record);
+  sessionWritesBySession.set(sessionId, existing);
+}
+function buildRateLimitExplanation(args) {
+  const summary = `Denied ${args.toolName}: session write limit ${args.currentCount}/${args.maxWritesPerSession} reached for the matched write policy.`;
+  return {
+    summary,
+    matchedReasonCode: "RATE_LIMIT_EXCEEDED",
+    toolName: args.toolName,
+    toolCategory: args.toolCategory ?? null,
+    role: args.authRole,
+    topicId: args.topicId ?? null,
+    policy: args.policy ?? null,
+    steps: [
+      {
+        stage: "policy_lookup",
+        outcome: "passed",
+        reasonCode: "WRITE_POLICY_MATCHED",
+        detail: "A matching write policy was found before evaluating the session limit."
+      },
+      {
+        stage: "rate_limit",
+        outcome: "failed",
+        reasonCode: "RATE_LIMIT_EXCEEDED",
+        detail: `This session has already recorded ${args.currentCount} writes and the matched rule caps it at ${args.maxWritesPerSession}.`
+      },
+      {
+        stage: "decision",
+        outcome: "failed",
+        reasonCode: "RATE_LIMIT_EXCEEDED",
+        detail: summary
+      }
+    ]
+  };
+}
+async function checkWritePolicy(toolName, topicId, authCtx) {
+  if (!isMutationTool(toolName)) {
+    return { allowed: true, permission: "allow", reason: "read_only_tool" };
+  }
+  try {
+    const result = await adminQuery(api2.mcpWritePolicy.checkAccess, {
+      topicId: topicId ?? void 0,
+      role: authCtx.role,
+      toolName
+    });
+    if (!result) {
+      return {
+        allowed: true,
+        permission: "allow",
+        toolCategory: null,
+        policy: null,
+        reason: "no_policy_response"
+      };
+    }
+    if (result.allowed && typeof result.maxWritesPerSession === "number" && Number.isFinite(result.maxWritesPerSession)) {
+      const currentCount = sessionWritesBySession.get(authCtx.sessionId)?.length ?? 0;
+      if (currentCount >= result.maxWritesPerSession) {
+        return {
+          allowed: false,
+          permission: "deny",
+          rationale: `Session write limit reached (${currentCount}/${result.maxWritesPerSession})`,
+          maxWritesPerSession: result.maxWritesPerSession,
+          toolCategory: typeof result.toolCategory === "string" ? result.toolCategory : null,
+          policy: result.policy && typeof result.policy === "object" ? result.policy : null,
+          explanation: buildRateLimitExplanation({
+            toolName,
+            toolCategory: typeof result.toolCategory === "string" ? result.toolCategory : null,
+            authRole: authCtx.role,
+            topicId,
+            maxWritesPerSession: result.maxWritesPerSession,
+            currentCount,
+            policy: result.policy && typeof result.policy === "object" ? result.policy : null
+          }),
+          reason: "rate_limit_exceeded"
+        };
+      }
+    }
+    return result;
+  } catch (err) {
+    console.error(
+      `[write-policy] Policy check failed for ${toolName}: ${err instanceof Error ? err.message : err}. Allowing (fail-open).`
+    );
+    return {
+      allowed: true,
+      permission: "allow",
+      toolCategory: null,
+      policy: null,
+      explanation: {
+        summary: "Allowed because write-policy evaluation failed and the runtime fell back to fail-open behavior.",
+        matchedReasonCode: "WRITE_POLICY_CHECK_ERROR",
+        steps: [
+          {
+            stage: "policy_lookup",
+            outcome: "failed",
+            reasonCode: "WRITE_POLICY_CHECK_ERROR",
+            detail: err instanceof Error ? err.message : "Unknown policy evaluation error."
+          },
+          {
+            stage: "decision",
+            outcome: "bypassed",
+            reasonCode: "WRITE_POLICY_CHECK_ERROR",
+            detail: "Write-policy infrastructure error did not block the mutation because this runtime is fail-open on evaluation errors."
+          }
+        ]
+      },
+      reason: "policy_check_error"
+    };
+  }
+}
+var LUCERN_HOME = path2.join(os.homedir(), ".lucern");
+path2.join(LUCERN_HOME, "credentials");
+
+export { buildHandlerMap, checkWritePolicy, createAdminClient, isMutationTool, recordWrite, runWithScopedClient };
+//# sourceMappingURL=runtime.js.map
+//# sourceMappingURL=runtime.js.map