@lucern/graph-primitives 1.0.0 → 1.0.1

package/dist/epistemicBeliefs.core.js

@@ -0,0 +1,1508 @@
+import { v } from 'convex/values';
+import { checkScopeAccess, checkProjectAccess } from '@lucern/access-control/access';
+import { assertSchemaEnumValue } from '@lucern/contracts/schema-helpers/enumValidation';
+import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
+import { componentsGeneric, anyApi, mutationGeneric, queryGeneric } from 'convex/server';
+import { normalizeTupleContradictionPolicy, createInheritedContractRecord, confidenceFromSL } from '@lucern/confidence';
+import { isNodeType, getLayerForNodeType } from '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
+import '@lucern/access-control/audience';
+import { getCurrentUserId } from '@lucern/access-control/auth';
+
+// src/epistemicBeliefs.core.ts
+var api = anyApi;
+componentsGeneric();
+var internal = anyApi;
+var mutation = mutationGeneric;
+var query = queryGeneric;
+
+// src/debug.ts
+function isGraphPrimitiveDebugEnabled() {
+  const env = globalThis.process?.env;
+  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
+}
+function debugGraphPrimitiveFallback(message, context) {
+  if (!isGraphPrimitiveDebugEnabled()) {
+    return;
+  }
+  console.debug(message, context ?? {});
+}
+
+// src/embeddingTrigger.ts
+async function scheduleEmbeddingGeneration(args) {
+  try {
+    await args.ctx.scheduler.runAfter(
+      0,
+      "embeddingActions:generateEpistemicNodeEmbedding",
+      {
+        nodeId: args.nodeId,
+        projectId: args.projectId ? String(args.projectId) : void 0,
+        topicId: args.topicId ? String(args.topicId) : void 0,
+        createdBy: args.createdBy,
+        nodeType: args.nodeType,
+        text: args.text.slice(0, 2e4),
+        hasAnswer: args.hasAnswer,
+        confidence: args.confidence
+      }
+    );
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[embeddingTrigger] Failed to schedule embedding generation",
+      {
+        error,
+        nodeId: String(args.nodeId),
+        nodeType: args.nodeType
+      }
+    );
+  }
+}
+
+// src/globalId.ts
+function generateGlobalId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
+    ""
+  );
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
+function asMappedProjectId(topic) {
+  if (!topic) {
+    return;
+  }
+  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
+  }
+  const metadata = topic.metadata || {};
+  const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
+  return candidate ? candidate : void 0;
+}
+function normalizeScopeValue(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function pickPrimaryTopic(candidates) {
+  return [...candidates].sort((a, b) => {
+    const depthA = a.depth ?? 9999;
+    const depthB = b.depth ?? 9999;
+    if (depthA !== depthB) {
+      return depthA - depthB;
+    }
+    const createdA = a.createdAt ?? Number.MAX_SAFE_INTEGER;
+    const createdB = b.createdAt ?? Number.MAX_SAFE_INTEGER;
+    if (createdA !== createdB) {
+      return createdA - createdB;
+    }
+    return String(a.name || "").localeCompare(String(b.name || ""));
+  })[0];
+}
+async function findTopicsByScopeAlias(ctx, scopeId) {
+  try {
+    return await ctx.db.query("topics").withIndex(
+      "by_graph_scope_project",
+      (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
+    ).collect();
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve scope alias via index",
+      {
+        error,
+        scopeId
+      }
+    );
+    const topics = await ctx.db.query("topics").collect();
+    return topics.filter((topic) => {
+      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
+      const mappedProjectId = asMappedProjectId(topic);
+      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
+    });
+  }
+}
+async function tryResolveHostTopicById(ctx, topicId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.get, {
+      id: topicId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by host query",
+      {
+        error,
+        topicId
+      }
+    );
+    return null;
+  }
+}
+async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: legacyScopeId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by legacy scope",
+      {
+        error,
+        legacyScopeId
+      }
+    );
+    return null;
+  }
+}
+async function resolveInheritedWorkspaceScope(ctx, topic) {
+  const MAX_DEPTH = 10;
+  let tenantId = normalizeScopeValue(topic.tenantId);
+  let workspaceId = normalizeScopeValue(topic.workspaceId);
+  if (tenantId && workspaceId) {
+    return { tenantId, workspaceId };
+  }
+  let current = topic;
+  for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
+    current = await ctx.db.get(current.parentTopicId);
+    if (!current) break;
+    if (!tenantId) {
+      tenantId = normalizeScopeValue(current.tenantId);
+    }
+    if (!workspaceId) {
+      workspaceId = normalizeScopeValue(current.workspaceId);
+    }
+    if (tenantId && workspaceId) break;
+  }
+  return { tenantId, workspaceId };
+}
+async function resolveTopicProjectScope(ctx, args) {
+  if (args.topicId) {
+    let topic = null;
+    try {
+      topic = await ctx.db.get(
+        args.topicId
+      );
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[topicScope] Failed to load topic by direct id",
+        {
+          error,
+          topicId: args.topicId
+        }
+      );
+    }
+    if (!topic) {
+      topic = await tryResolveHostTopicById(ctx, String(args.topicId));
+    }
+    if (!topic) {
+      topic = pickPrimaryTopic(
+        await findTopicsByScopeAlias(ctx, String(args.topicId))
+      ) ?? null;
+    }
+    if (!topic) {
+      throw new Error(`Topic not found: ${String(args.topicId)}`);
+    }
+    const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
+    const mapped = asMappedProjectId(topic);
+    if (mapped) {
+      return {
+        topicId: topic._id,
+        projectId: mapped,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "topic"
+      };
+    }
+    return {
+      topicId: topic._id,
+      tenantId: inherited.tenantId,
+      workspaceId: inherited.workspaceId,
+      source: "topic"
+    };
+  }
+  if (args.projectId) {
+    let directTopic = null;
+    try {
+      directTopic = await ctx.db.get(
+        args.projectId
+      );
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[topicScope] Failed to load direct project topic",
+        {
+          error,
+          projectId: args.projectId
+        }
+      );
+    }
+    if (directTopic) {
+      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
+      const mapped = asMappedProjectId(directTopic);
+      return {
+        topicId: directTopic._id,
+        projectId: mapped ?? args.projectId,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "topic_inferred"
+      };
+    }
+    directTopic = await tryResolveHostTopicByLegacyScope(ctx, args.projectId);
+    if (directTopic) {
+      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
+      const mapped = asMappedProjectId(directTopic);
+      return {
+        topicId: directTopic._id,
+        projectId: mapped ?? args.projectId,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "topic_inferred"
+      };
+    }
+    const topics = await findTopicsByScopeAlias(ctx, args.projectId);
+    const primary = pickPrimaryTopic(topics);
+    if (primary) {
+      const inherited = await resolveInheritedWorkspaceScope(ctx, primary);
+      return {
+        topicId: primary._id,
+        projectId: args.projectId,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "project_mapped_topic"
+      };
+    }
+    throw new Error(
+      `Legacy project scope ${String(args.projectId)} has no mapped topic.`
+    );
+  }
+  throw new Error(
+    "Missing scope: provide topicId (preferred) or legacy projectId alias."
+  );
+}
+var optionalScopeArgs = {
+  projectId: v.optional(v.string()),
+  topicId: v.optional(v.string())
+};
+function normalizeScopeValue2(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function throwWorkspaceIsolationError(args) {
+  const error = new Error(args.message);
+  error.status = 409;
+  error.code = "INVARIANT_VIOLATION";
+  error.invariantCode = args.invariantCode;
+  error.suggestion = args.suggestion;
+  error.details = args.details;
+  throw error;
+}
+function assertWorkspaceScopedEpistemicNodeScope(args) {
+  const layer = isNodeType(args.nodeType) ? getLayerForNodeType(args.nodeType) : void 0;
+  if (layer === "ontological") {
+    return;
+  }
+  const workspaceId = normalizeScopeValue2(args.scope.workspaceId);
+  if (workspaceId) {
+    return;
+  }
+  throwWorkspaceIsolationError({
+    message: "Workspace-scoped reasoning isolation requires workspaceId on non-ontological node creation.",
+    invariantCode: "workspace.scope_required_for_epistemic_nodes",
+    suggestion: "Resolve the topic/project scope through a workspace-bound topic before creating epistemic nodes.",
+    details: {
+      mutationName: args.mutationName,
+      nodeType: args.nodeType,
+      topicId: args.scope.topicId,
+      projectId: args.scope.projectId
+    }
+  });
+}
+function nodeMatchesWorkspaceReasoningScope(node, scope) {
+  if (!node) {
+    return false;
+  }
+  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
+  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
+  const nodeTenantId = normalizeScopeValue2(node.tenantId);
+  const nodeWorkspaceId = normalizeScopeValue2(node.workspaceId);
+  const epistemicLayer = typeof node.epistemicLayer === "string" ? node.epistemicLayer : void 0;
+  if (scopeTenantId && nodeTenantId && scopeTenantId !== nodeTenantId) {
+    return false;
+  }
+  if (epistemicLayer === "ontological" && nodeWorkspaceId === void 0) {
+    return true;
+  }
+  if (!scopeWorkspaceId && node.publicationStatus === "published") {
+    return true;
+  }
+  if (!scopeWorkspaceId) {
+    return nodeWorkspaceId === void 0;
+  }
+  return scopeWorkspaceId === nodeWorkspaceId;
+}
+
+// src/topicProjectOverlay.ts
+var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
+function readNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => readNonEmptyString(entry)).filter((entry) => Boolean(entry));
+}
+function readMetadata(topic) {
+  return topic.metadata && typeof topic.metadata === "object" ? topic.metadata : {};
+}
+function readLegacyProjectId(value) {
+  if (!value) {
+    return;
+  }
+  return readNonEmptyString(value[LEGACY_SCOPE_FIELD2]);
+}
+function coerceVisibility(value) {
+  return value === "private" || value === "team" || value === "firm" || value === "external" || value === "public" ? value : void 0;
+}
+function coerceStatus(value) {
+  return value === "active" || value === "archived" || value === "watching" ? value : void 0;
+}
+function mapProjectType(topic, metadata) {
+  const explicit = readNonEmptyString(metadata.projectType);
+  if (explicit) {
+    return explicit;
+  }
+  if (topic.type === "theme") {
+    return "thematic";
+  }
+  return readNonEmptyString(topic.type) || "general";
+}
+function isProjectLikeTopic(topic) {
+  const metadata = readMetadata(topic);
+  return topic.type === "theme" || topic.type === "thematic" || topic.type === "deal" || topic.type === "monitoring" || readLegacyProjectId(topic) !== void 0 || readNonEmptyString(metadata.projectType) !== void 0;
+}
+function isMissingLucernChildComponentError(error) {
+  const message = getErrorMessage(error);
+  return message.includes(
+    'Child component ComponentName(Identifier("lucern")) not found'
+  ) || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return "unknown error";
+}
+async function resolveTopicDoc(ctx, scopeId) {
+  if (ctx?.db && typeof ctx.db.get === "function") {
+    try {
+      const directTopic = await ctx.db.get(
+        scopeId
+      );
+      if (directTopic) {
+        return directTopic;
+      }
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[topicProjectOverlay] Failed to resolve topic by direct ID",
+        {
+          error,
+          scopeId
+        }
+      );
+    }
+  }
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    const topic = await ctx.runQuery(api.topics.get, {
+      id: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicProjectOverlay] Failed to resolve topic by ID query",
+      {
+        error,
+        scopeId
+      }
+    );
+  }
+  try {
+    const topic = await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicProjectOverlay] Failed to resolve topic by legacy scope ID",
+      { error, scopeId }
+    );
+  }
+  return null;
+}
+function materializeTopicProjectOverlay(topic, idMode = "legacy") {
+  const metadata = readMetadata(topic);
+  const topicId = String(topic._id);
+  const legacyProjectId = readLegacyProjectId(topic) || readLegacyProjectId(metadata) || readNonEmptyString(metadata.legacyProjectId);
+  const storageProjectId = legacyProjectId || topicId;
+  const outwardId = idMode === "topic" ? topicId : storageProjectId;
+  const visibility = coerceVisibility(topic.visibility) || coerceVisibility(metadata.visibility) || "private";
+  const status = coerceStatus(topic.status) || coerceStatus(metadata.status) || "active";
+  const createdAt = typeof topic.createdAt === "number" ? topic.createdAt : typeof topic._creationTime === "number" ? topic._creationTime : 0;
+  const updatedAt = typeof topic.updatedAt === "number" ? topic.updatedAt : typeof metadata.updatedAt === "number" ? metadata.updatedAt : createdAt;
+  return {
+    ...metadata,
+    _id: outwardId,
+    projectId: outwardId,
+    topicId,
+    storageProjectId,
+    legacyProjectId,
+    name: readNonEmptyString(topic.name) || "Untitled Theme",
+    type: mapProjectType(topic, metadata),
+    description: readNonEmptyString(topic.description),
+    ownerId: readNonEmptyString(metadata.ownerId) || readNonEmptyString(topic.createdBy) || "system",
+    sharedWith: readStringArray(metadata.sharedWith),
+    visibility,
+    tenantId: readNonEmptyString(topic.tenantId) || readNonEmptyString(metadata.tenantId),
+    workspaceId: readNonEmptyString(topic.workspaceId) || readNonEmptyString(metadata.workspaceId),
+    status,
+    tags: readStringArray(metadata.tags),
+    chatCount: typeof metadata.chatCount === "number" ? metadata.chatCount : 0,
+    artifactCount: typeof metadata.artifactCount === "number" ? metadata.artifactCount : 0,
+    lastActivityAt: typeof metadata.lastActivityAt === "number" ? metadata.lastActivityAt : updatedAt,
+    _creationTime: typeof topic._creationTime === "number" ? topic._creationTime : createdAt,
+    createdAt,
+    updatedAt
+  };
+}
+async function resolveTopicProjectOverlay(ctx, scopeId, options = {}) {
+  const topic = await resolveTopicDoc(ctx, scopeId);
+  if (!topic) {
+    return null;
+  }
+  if (options.projectLikeOnly !== false && !isProjectLikeTopic(topic)) {
+    return null;
+  }
+  return materializeTopicProjectOverlay(topic, options.idMode);
+}
+async function listTopicProjectOverlays(ctx, options = {}) {
+  let allTopics = [];
+  if (ctx?.db?.query && typeof ctx.db.query === "function") {
+    try {
+      allTopics = await ctx.db.query("topics").collect();
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[topicProjectOverlay] Failed to read topics table; falling back to API",
+        { error }
+      );
+      allTopics = [];
+    }
+  }
+  if (allTopics.length === 0 && typeof ctx.runQuery === "function") {
+    allTopics = (await ctx.runQuery(api.topics.list, {}) ?? []) || [];
+  }
+  return allTopics.filter(
+    (topic) => options.projectLikeOnly === false || isProjectLikeTopic(topic)
+  ).map((topic) => materializeTopicProjectOverlay(topic, options.idMode));
+}
+async function patchTopicProjectOverlay(ctx, scopeId, value) {
+  const topic = await resolveTopicDoc(ctx, scopeId);
+  if (!topic) {
+    return null;
+  }
+  const nextMetadata = { ...readMetadata(topic) };
+  const patch = {};
+  const topicUpdateArgs = {
+    id: String(topic._id)
+  };
+  for (const [key, rawValue] of Object.entries(value)) {
+    switch (key) {
+      case "_id":
+      case "projectId":
+      case "topicId":
+      case "legacyProjectId":
+      case "storageProjectId":
+        break;
+      case "name":
+      case "description":
+        patch[key] = rawValue;
+        topicUpdateArgs[key] = rawValue;
+        break;
+      case "tenantId":
+      case "workspaceId":
+      case "ownerId":
+        throw new Error(
+          `patchTopicProjectOverlay cannot mutate ${key} via component-owned topics`
+        );
+      case "status": {
+        const status = coerceStatus(rawValue);
+        if (status) {
+          patch.status = status;
+          topicUpdateArgs.status = status;
+        }
+        break;
+      }
+      case "visibility": {
+        const visibility = coerceVisibility(rawValue);
+        if (visibility) {
+          patch.visibility = visibility;
+          topicUpdateArgs.visibility = visibility;
+        }
+        break;
+      }
+      case "type": {
+        const projectType = readNonEmptyString(rawValue);
+        if (projectType) {
+          nextMetadata.projectType = projectType;
+        } else {
+          delete nextMetadata.projectType;
+        }
+        break;
+      }
+      case "updatedAt":
+      case "createdAt":
+        break;
+      default:
+        if (rawValue === void 0) {
+          delete nextMetadata[key];
+        } else {
+          nextMetadata[key] = rawValue;
+        }
+    }
+  }
+  patch.updatedAt = Date.now();
+  patch.metadata = nextMetadata;
+  topicUpdateArgs.metadata = nextMetadata;
+  if (typeof ctx.runMutation === "function") {
+    try {
+      await ctx.runMutation(api.topics.update, topicUpdateArgs);
+    } catch (error) {
+      if (!isMissingLucernChildComponentError(error) || !ctx?.db || typeof ctx.db.patch !== "function") {
+        throw error;
+      }
+      await ctx.db.patch(String(topic._id), patch);
+    }
+  } else if (ctx?.db && typeof ctx.db.patch === "function") {
+    await ctx.db.patch(String(topic._id), patch);
+  } else {
+    throw new Error(
+      "Cannot patch topic without component adapter (ctx.runMutation unavailable)"
+    );
+  }
+  return materializeTopicProjectOverlay({
+    ...topic,
+    ...patch,
+    metadata: nextMetadata
+  });
+}
+
+// src/resolvers.ts
+function isMissingLucernChildComponentError2(error) {
+  const message = getErrorMessage2(error);
+  return message.includes(
+    'Child component ComponentName(Identifier("lucern")) not found'
+  ) || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
+}
+function getErrorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return "unknown error";
+}
+function isAdvisoryTopicPatch(value) {
+  const advisoryKeys = /* @__PURE__ */ new Set(["lastActivityAt", "updatedAt"]);
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((key) => advisoryKeys.has(key));
+}
+async function patchProjectWithTolerance(ctx, projectId, value) {
+  try {
+    await patchTopicProjectOverlay(ctx, projectId, value);
+  } catch (error) {
+    if (!isAdvisoryTopicPatch(value) || !isMissingLucernChildComponentError2(error)) {
+      throw error;
+    }
+    console.warn(
+      "[lucern graph-primitives] Non-fatal advisory topic patch failure",
+      {
+        projectId,
+        keys: Object.keys(value),
+        error: getErrorMessage2(error)
+      }
+    );
+  }
+}
+function defaultResolvers() {
+  return {
+    getProject: (ctx, projectId) => resolveTopicProjectOverlay(ctx, projectId, {
+      idMode: "legacy",
+      projectLikeOnly: false
+    }),
+    patchProject: (ctx, projectId, value) => patchProjectWithTolerance(ctx, projectId, value),
+    listTopics: (ctx) => listTopicProjectOverlays(ctx, {
+      idMode: "legacy"
+    }),
+    getFinalArtifact: (ctx, artifactId) => ctx.db.get(artifactId)
+  };
+}
+var resolverOverrides = {};
+function resolveGraphPrimitivesAppResolvers(_ctx) {
+  return {
+    ...defaultResolvers(),
+    ...resolverOverrides
+  };
+}
+
+// src/epistemicBeliefs.helpers.ts
+v.id("epistemicNodes");
+var DEFAULT_PROJECT_BELIEF_LIMIT = 250;
+var MAX_PROJECT_BELIEF_LIMIT = 1e3;
+var optionalBeliefScopeArgs = optionalScopeArgs;
+var DEFAULT_CONFIDENCE_POLICY = {
+  scoringMode: "after_worktree",
+  tupleContradiction: normalizeTupleContradictionPolicy()
+};
+function throwStructuredMutationError(args) {
+  const error = new Error(args.message);
+  error.status = args.status;
+  error.code = args.code;
+  error.invariantCode = args.invariantCode;
+  error.suggestion = args.suggestion;
+  error.details = args.details;
+  throw error;
+}
+function assertBaseRateInRange(baseRate, field = "baseRate") {
+  if (baseRate < 0 || baseRate > 1) {
+    throwStructuredMutationError({
+      message: `${field} must be within [0, 1].`,
+      status: 400,
+      code: "INVALID_ARGUMENT",
+      invariantCode: "request.valid_shape",
+      suggestion: `Clamp ${field} into the inclusive [0, 1] interval.`,
+      details: { field, baseRate }
+    });
+  }
+  return baseRate;
+}
+function buildBeliefConfidenceRow(args) {
+  return {
+    beliefId: args.beliefId,
+    confidence: confidenceFromSL(
+      args.belief,
+      args.disbelief,
+      args.uncertainty,
+      args.baseRate
+    ),
+    belief: args.belief,
+    disbelief: args.disbelief,
+    uncertainty: args.uncertainty,
+    baseRate: args.baseRate,
+    slOperator: args.slOperator ?? "manual_assessment",
+    trigger: args.trigger,
+    ...args.rationale ? { rationale: args.rationale } : {},
+    assessedBy: args.assessedBy,
+    assessedAt: args.assessedAt,
+    ...args.triggeringEvidenceId ? {
+      triggeringEvidenceId: args.triggeringEvidenceId,
+      triggeringEvidenceIds: [String(args.triggeringEvidenceId)]
+    } : {},
+    ...args.triggeringContradictionId ? {
+      triggeringContradictionId: args.triggeringContradictionId
+    } : {},
+    ...args.triggeringWorktreeId ? { triggeringWorktreeId: args.triggeringWorktreeId } : {}
+  };
+}
+function clampBeliefLimit(limit, fallback = DEFAULT_PROJECT_BELIEF_LIMIT) {
+  if (!Number.isFinite(limit)) {
+    return fallback;
+  }
+  return Math.max(
+    1,
+    Math.min(Math.floor(limit), MAX_PROJECT_BELIEF_LIMIT)
+  );
+}
+function generateContentHash(text) {
+  const content = `belief:${text.trim().toLowerCase().replace(/\s+/g, " ")}`;
+  let hash = 5381;
+  for (let i = 0; i < content.length; i++) {
+    hash = (hash << 5) + hash + content.charCodeAt(i);
+    hash &= hash;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+function normalizePillar(pillar) {
+  if (!pillar) {
+    return "other";
+  }
+  const lower = pillar.toLowerCase();
+  const validPillars = [
+    "market",
+    "competition",
+    "product",
+    "team",
+    "financials",
+    "regulatory",
+    "timing",
+    "customer",
+    "technology",
+    "distribution",
+    "deal",
+    "risks"
+  ];
+  return validPillars.find((p) => lower.includes(p)) || "other";
+}
+async function markBeliefGraphDirty(ctx, scope) {
+  const projectId = typeof scope.projectId === "string" && scope.projectId.trim().length > 0 ? scope.projectId : void 0;
+  const topicId = typeof scope.topicId === "string" && scope.topicId.trim().length > 0 ? scope.topicId : void 0;
+  if (!projectId && !topicId) {
+    return;
+  }
+  if (projectId) {
+    await ctx.scheduler.runAfter(
+      0,
+      internal.graphAnalysisCache.markCacheStaleInternal,
+      { projectId }
+    );
+  }
+  if (topicId) {
+    await ctx.scheduler.runAfter(
+      0,
+      internal.graphAnalysisCache.markCacheStaleByTopic,
+      { topicId }
+    );
+  }
+  await resolveGraphPrimitivesAppResolvers().patchProject(
+    ctx,
+    topicId ?? projectId,
+    {
+      lastActivityAt: Date.now()
+    }
+  );
+}
+async function getActiveConfidencePolicy(ctx) {
+  try {
+    const activeConfig = await ctx.db.query("logicSprintScoring").withIndex("by_active", (q) => q.eq("isActive", true)).first();
+    return {
+      scoringMode: activeConfig?.confidencePolicy === "always" ? "always" : DEFAULT_CONFIDENCE_POLICY.scoringMode,
+      tupleContradiction: normalizeTupleContradictionPolicy(
+        activeConfig?.tupleContradictionPolicy
+      )
+    };
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[epistemicBeliefs] Failed to load active confidence policy",
+      {
+        error
+      }
+    );
+    return DEFAULT_CONFIDENCE_POLICY;
+  }
+}
+async function requireAuthenticatedUserId(ctx) {
+  const userId = await getCurrentUserId(
+    ctx
+  );
+  if (!userId) {
+    throwStructuredMutationError({
+      message: "Authentication required.",
+      status: 401,
+      code: "AUTHENTICATION_REQUIRED",
+      invariantCode: "auth.required",
+      suggestion: "Provide a valid bearer token before invoking belief mutations."
+    });
+  }
+  return userId;
+}
+async function requireProjectWriteAccess(ctx, projectId, userId) {
+  const hasAccess = await checkProjectAccess(
+    ctx,
+    projectId,
+    userId
+  );
+  if (!hasAccess) {
+    throwStructuredMutationError({
+      message: "Project access required.",
+      status: 403,
+      code: "FORBIDDEN",
+      invariantCode: "policy.scope_required",
+      suggestion: "Request write access for the project and retry.",
+      details: { projectId, userId }
+    });
+  }
+}
+
+// src/epistemicBeliefs.core.ts
+var create = mutation({
+  args: {
+    ...optionalBeliefScopeArgs,
+    formulation: v.string(),
+    beliefType: v.optional(v.string()),
+    rationale: v.optional(v.string()),
+    confidence: v.optional(
+      v.union(
+        v.literal("untested"),
+        v.literal("high"),
+        v.literal("medium"),
+        v.literal("low")
+      )
+    ),
+    pillar: v.optional(v.string()),
+    worktreeId: v.optional(v.string()),
+    sourceType: v.optional(
+      v.union(
+        v.literal("human"),
+        v.literal("ai_extracted"),
+        v.literal("ai_generated")
+      )
+    ),
+    userId: v.string(),
+    // === CLASSIFICATION FIELDS ===
+    reversibility: v.optional(
+      v.union(
+        v.literal("irreversible"),
+        v.literal("hard_to_reverse"),
+        v.literal("reversible"),
+        v.literal("trivial")
+      )
+    ),
+    predictionMeta: v.optional(
+      v.object({
+        isPrediction: v.boolean(),
+        registeredAt: v.number(),
+        expectedBy: v.optional(v.number())
+      })
+    ),
+    baseRate: v.optional(v.number()),
+    metadata: v.optional(v.any())
+    // Additional metadata including isConditional
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const scope = await resolveTopicProjectScope(ctx, {
+      topicId: args.topicId,
+      projectId: args.projectId
+    });
+    assertWorkspaceScopedEpistemicNodeScope({
+      scope,
+      nodeType: "belief",
+      mutationName: "epistemicBeliefs.create"
+    });
+    const topic = await ctx.db.get(scope.topicId);
+    const normalizedBeliefType = await assertSchemaEnumValue(ctx, {
+      category: "belief_type",
+      value: args.beliefType,
+      tenantId: topic?.tenantId,
+      context: "epistemicBeliefs.create"
+    });
+    if (scope.projectId) {
+      await requireProjectWriteAccess(
+        ctx,
+        scope.projectId,
+        authenticatedUserId
+      );
+    }
+    const now = Date.now();
+    const baseRate = assertBaseRateInRange(args.baseRate ?? 0.5);
+    const initialBeliefStatus = args.worktreeId ? "hypothesis" : "assumption";
+    const initialEpistemicStatus = args.worktreeId ? "hypothesis" : "assumption";
+    const seedOpinion = {
+      opinion_b: 0,
+      opinion_d: 0,
+      opinion_u: 1,
+      opinion_a: baseRate
+    };
+    const pillar = normalizePillar(args.pillar);
+    const additionalMeta = args.metadata || {};
+    const beliefGlobalId = generateGlobalId();
+    const nodeId = await ctx.db.insert("epistemicNodes", {
+      globalId: beliefGlobalId,
+      nodeType: "belief",
+      epistemicLayer: "L3",
+      canonicalText: args.formulation,
+      contentHash: generateContentHash(args.formulation),
+      content: args.rationale,
+      title: args.formulation.slice(0, 100) + (args.formulation.length > 100 ? "..." : ""),
+      metadata: {
+        pillar,
+        // No confidenceLevel — only set after worktree completion via modulateConfidence()
+        status: "active",
+        worktreeId: args.worktreeId,
+        beliefStatus: initialBeliefStatus,
+        epistemicStatus: initialEpistemicStatus,
+        tupleContradicted: false,
+        ...normalizedBeliefType ? { beliefType: normalizedBeliefType } : {},
+        ...additionalMeta
+        // Includes isConditional if provided
+      },
+      beliefStatus: initialBeliefStatus,
+      ...seedOpinion,
+      tupleContradicted: false,
+      // Classification fields
+      reversibility: args.reversibility ?? "reversible",
+      predictionMeta: args.predictionMeta,
+      // Infer epistemicStatus based on context
+      epistemicStatus: initialEpistemicStatus,
+      sourceType: args.sourceType || "human",
+      ...normalizedBeliefType ? { beliefType: normalizedBeliefType } : {},
+      confidence: void 0,
+      // No scalar confidence until worktree completion
+      verificationStatus: "unverified",
+      status: "active",
+      topicId: scope.topicId,
+      projectId: scope.projectId,
+      tenantId: scope.tenantId,
+      workspaceId: scope.workspaceId,
+      createdBy: authenticatedUserId,
+      createdAt: now,
+      updatedAt: now
+    });
+    await ctx.db.insert(
+      "beliefConfidence",
+      buildBeliefConfidenceRow({
+        beliefId: nodeId,
+        belief: seedOpinion.opinion_b,
+        disbelief: seedOpinion.opinion_d,
+        uncertainty: seedOpinion.opinion_u,
+        baseRate,
+        trigger: "initial",
+        rationale: "LKC-2 mandatory prior: seeded vacuous opinion at belief creation.",
+        assessedBy: authenticatedUserId,
+        assessedAt: now,
+        slOperator: "manual_assessment"
+      })
+    );
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId,
+      operation: "upsert"
+    });
+    await scheduleEmbeddingGeneration({
+      ctx,
+      nodeId,
+      projectId: scope.projectId,
+      topicId: scope.topicId,
+      createdBy: authenticatedUserId,
+      nodeType: "belief",
+      text: args.formulation
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "belief",
+      entityId: nodeId,
+      changeType: "created",
+      changedAt: now,
+      changedBy: authenticatedUserId,
+      isAgent: false,
+      previousState: null,
+      newState: {
+        formulation: args.formulation,
+        status: "active",
+        baseRate: seedOpinion.opinion_a,
+        tupleContradicted: false,
+        opinion: {
+          b: seedOpinion.opinion_b,
+          d: seedOpinion.opinion_d,
+          u: seedOpinion.opinion_u,
+          a: seedOpinion.opinion_a
+        }
+      },
+      projectId: scope.projectId,
+      topicId: String(scope.topicId)
+    });
+    if (scope.projectId || scope.topicId) {
+      await ctx.scheduler.runAfter(
+        0,
+        "embeddingActions:generateEpistemicNodeEmbedding",
+        {
+          nodeId,
+          projectId: scope.projectId,
+          topicId: String(scope.topicId),
+          createdBy: authenticatedUserId,
+          nodeType: "belief",
+          text: args.rationale ? `${args.formulation}
+
+Rationale: ${args.rationale}` : args.formulation
+          // Don't pass confidence — "untested" is a string, but the
+          // embedding action expects v.optional(v.number()). New beliefs
+          // have no numeric confidence until scoring.
+        }
+      );
+    }
+    if (scope.projectId || scope.topicId) {
+      await ctx.scheduler.runAfter(
+        2e3,
+        // 2 second delay
+        internal.nodeClassification.scheduleClassification,
+        {
+          nodeId,
+          nodeType: "belief",
+          projectId: scope.projectId,
+          topicId: String(scope.topicId)
+        }
+      );
+    }
+    if (pillar === "other" && (scope.projectId || scope.topicId)) {
+      await ctx.scheduler.runAfter(
+        2500,
+        "beliefCategorization:autoCategorizeBelief",
+        {
+          nodeId,
+          projectId: scope.projectId,
+          topicId: String(scope.topicId)
+        }
+      );
+    }
+    if (scope.projectId || scope.topicId) {
+      await ctx.scheduler.runAfter(
+        3e3,
+        // 3 second delay — after entity extraction
+        internal.beliefTemporalClassifier.classifyBelief,
+        {
+          nodeId,
+          projectId: scope.projectId,
+          topicId: String(scope.topicId)
+        }
+      );
+    }
+    await markBeliefGraphDirty(ctx, {
+      projectId: scope.projectId,
+      topicId: String(scope.topicId)
+    });
+    return { nodeId };
+  }
+});
+var getById = query({
+  args: {
+    nodeId: v.optional(v.id("epistemicNodes")),
+    beliefId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const id = args.nodeId ?? args.beliefId;
+    if (!id) {
+      return null;
+    }
+    const node = await ctx.db.get(id);
+    if (!node || node.nodeType !== "belief") {
+      return null;
+    }
+    return node;
+  }
+});
+var refineBelief = mutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    canonicalText: v.optional(v.string()),
+    title: v.optional(v.string()),
+    rationale: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const now = Date.now();
+    const node = await ctx.db.get(args.nodeId);
+    if (!node) {
+      throwStructuredMutationError({
+        message: "Belief not found.",
+        status: 404,
+        code: "NOT_FOUND",
+        invariantCode: "belief.exists",
+        suggestion: "Verify nodeId points to an existing belief before refining.",
+        details: { nodeId: args.nodeId }
+      });
+    }
+    if (node.nodeType !== "belief") {
+      throwStructuredMutationError({
+        message: `refineBelief only applies to belief nodes. Received nodeType "${node.nodeType}".`,
+        status: 400,
+        code: "INVALID_ARGUMENT",
+        invariantCode: "entity.no_refine",
+        suggestion: "Use entityLifecycle.updateEntityAttributes for entity mutations.",
+        details: { nodeId: args.nodeId, nodeType: node.nodeType }
+      });
+    }
+    if (!node.projectId) {
+      throwStructuredMutationError({
+        message: "Belief has no project scope.",
+        status: 400,
+        code: "MISSING_SCOPE",
+        invariantCode: "belief.project_required",
+        suggestion: "Belief must have a projectId to refine.",
+        details: { nodeId: args.nodeId }
+      });
+    }
+    await requireProjectWriteAccess(ctx, node.projectId, authenticatedUserId);
+    if (typeof node.confidence === "number" && Number.isFinite(node.confidence)) {
+      throwStructuredMutationError({
+        message: "Scored beliefs are immutable. Use forkBelief to evolve a scored belief.",
+        status: 409,
+        code: "CONFLICT",
+        invariantCode: "belief.versioning.scored_immutable",
+        suggestion: "Use forkBelief() to create a new version instead of refining in place.",
+        details: { nodeId: args.nodeId, confidence: node.confidence }
+      });
+    }
+    const nextText = typeof args.canonicalText === "string" && args.canonicalText.trim().length > 0 ? args.canonicalText.trim() : void 0;
+    const nextTitle = typeof args.title === "string" && args.title.trim().length > 0 ? args.title.trim() : void 0;
+    const patch = { updatedAt: now };
+    if (nextText !== void 0) {
+      patch.canonicalText = nextText;
+      patch.title = nextTitle ?? nextText.slice(0, 100) + (nextText.length > 100 ? "..." : "");
+      patch.contentHash = generateContentHash(nextText);
+    } else if (nextTitle !== void 0) {
+      patch.title = nextTitle;
+    }
+    if (args.rationale !== void 0) {
+      patch.content = args.rationale;
+    }
+    await ctx.db.patch(args.nodeId, patch);
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: args.nodeId,
+      operation: "upsert"
+    });
+    if (nextText !== void 0) {
+      await scheduleEmbeddingGeneration({
+        ctx,
+        nodeId: args.nodeId,
+        projectId: node.projectId,
+        topicId: node.topicId,
+        createdBy: authenticatedUserId,
+        nodeType: "belief",
+        text: args.rationale ? `${nextText}
+
+Rationale: ${args.rationale}` : nextText
+      });
+    }
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "belief",
+      entityId: args.nodeId,
+      changeType: "updated",
+      changedAt: now,
+      changedBy: authenticatedUserId,
+      isAgent: false,
+      previousState: {
+        canonicalText: node.canonicalText,
+        title: node.title,
+        content: node.content
+      },
+      newState: {
+        canonicalText: patch.canonicalText ?? node.canonicalText,
+        title: patch.title ?? node.title,
+        content: patch.content ?? node.content,
+        action: "refined",
+        rationale: args.rationale
+      },
+      projectId: node.projectId,
+      topicId: node.topicId
+    });
+    await markBeliefGraphDirty(ctx, {
+      projectId: node.projectId,
+      topicId: node.topicId
+    });
+    return { nodeId: args.nodeId };
+  }
+});
+var getByProject = query({
+  args: {
+    ...optionalBeliefScopeArgs,
+    status: v.optional(
+      v.union(
+        v.literal("active"),
+        v.literal("superseded"),
+        v.literal("archived")
+      )
+    ),
+    userId: v.optional(v.string()),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    if (!args.projectId && !args.topicId) {
+      return [];
+    }
+    const pageSize = clampBeliefLimit(args.limit);
+    const scanLimit = Math.min(pageSize * 3, MAX_PROJECT_BELIEF_LIMIT);
+    let scope;
+    try {
+      scope = await resolveTopicProjectScope(ctx, {
+        projectId: args.projectId,
+        topicId: args.topicId
+      });
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[epistemicBeliefs] Failed to resolve project scope",
+        {
+          error,
+          projectId: args.projectId,
+          topicId: args.topicId
+        }
+      );
+      return [];
+    }
+    if (args.userId) {
+      const scopeId = scope.topicId ? String(scope.topicId) : scope.projectId;
+      if (!scopeId) {
+        return [];
+      }
+      const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+      if (!hasAccess) {
+        return [];
+      }
+    }
+    const query3 = ctx.db.query("epistemicNodes").withIndex(
+      "by_topic_type",
+      (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
+    );
+    const nodes = await query3.order("desc").take(scanLimit);
+    const scopedNodes = nodes.filter(
+      (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
+    );
+    if (args.status) {
+      return scopedNodes.filter((n) => n.status === args.status).slice(0, pageSize);
+    }
+    return scopedNodes.filter((n) => n.status === "active").slice(0, pageSize);
+  }
+});
+var getByTopic = query({
+  args: {
+    topicId: v.string(),
+    status: v.optional(
+      v.union(
+        v.literal("active"),
+        v.literal("superseded"),
+        v.literal("archived")
+      )
+    ),
+    userId: v.optional(v.string()),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const pageSize = clampBeliefLimit(args.limit);
+    const scanLimit = Math.min(pageSize * 3, MAX_PROJECT_BELIEF_LIMIT);
+    const scope = await resolveTopicProjectScope(ctx, {
+      topicId: args.topicId
+    });
+    const query3 = ctx.db.query("epistemicNodes").withIndex(
+      "by_topic_type",
+      (q) => q.eq("topicId", args.topicId).eq("nodeType", "belief")
+    );
+    const nodes = await query3.order("desc").take(scanLimit);
+    const scopedNodes = nodes.filter(
+      (node) => nodeMatchesWorkspaceReasoningScope(node, {
+        tenantId: scope.tenantId,
+        workspaceId: scope.workspaceId
+      })
+    );
+    if (args.status) {
+      return scopedNodes.filter((n) => n.status === args.status).slice(0, pageSize);
+    }
+    return scopedNodes.filter((n) => n.status === "active").slice(0, pageSize);
+  }
+});
+var forkBelief = mutation({
+  args: {
+    parentNodeId: v.id("epistemicNodes"),
+    newFormulation: v.string(),
+    forkReason: v.union(
+      v.literal("refinement"),
+      v.literal("contradiction_response"),
+      v.literal("scope_change"),
+      v.literal("confidence_collapse"),
+      v.literal("manual")
+    ),
+    rationale: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const authenticatedUserId = await requireAuthenticatedUserId(ctx);
+    const now = Date.now();
+    await getActiveConfidencePolicy(ctx);
+    const parent = await ctx.db.get(args.parentNodeId);
+    if (!parent) {
+      throwStructuredMutationError({
+        message: "Parent node not found.",
+        status: 404,
+        code: "NOT_FOUND",
+        invariantCode: "belief.exists",
+        suggestion: "Verify parentNodeId points to an existing node before forking.",
+        details: { parentNodeId: args.parentNodeId }
+      });
+    }
+    if (parent.nodeType !== "belief") {
+      throwStructuredMutationError({
+        message: `forkBelief only applies to belief nodes. Received nodeType "${parent.nodeType}". Entity nodes (company, person, investor, etc.) are mutable \u2014 use entityLifecycle.updateEntityAttributes instead of forking.`,
+        status: 400,
+        code: "INVALID_ARGUMENT",
+        invariantCode: "entity.no_fork",
+        suggestion: "Use entityLifecycle.updateEntityAttributes for entity mutations. forkBelief is for belief nodes only.",
+        details: { parentNodeId: args.parentNodeId, nodeType: parent.nodeType }
+      });
+    }
+    if (!parent.projectId) {
+      throwStructuredMutationError({
+        message: "Parent belief has no project scope.",
+        status: 400,
+        code: "MISSING_SCOPE",
+        invariantCode: "belief.project_required",
+        suggestion: "Belief must have a projectId to fork.",
+        details: { parentNodeId: args.parentNodeId }
+      });
+    }
+    await requireProjectWriteAccess(ctx, parent.projectId, authenticatedUserId);
+    const metadata = parent.metadata;
+    const forkBeliefStatus = "hypothesis";
+    const newBeliefGlobalId = generateGlobalId();
+    const newNodeId = await ctx.db.insert("epistemicNodes", {
+      globalId: newBeliefGlobalId,
+      nodeType: "belief",
+      epistemicLayer: "L3",
+      canonicalText: args.newFormulation,
+      contentHash: generateContentHash(args.newFormulation),
+      content: args.rationale || parent.content,
+      title: args.newFormulation.slice(0, 100) + (args.newFormulation.length > 100 ? "..." : ""),
+      metadata: {
+        ...metadata,
+        forkedFrom: args.parentNodeId,
+        forkReason: args.forkReason,
+        forkTimestamp: now,
+        forkedBy: authenticatedUserId,
+        status: "active",
+        beliefStatus: forkBeliefStatus,
+        tupleContradicted: false
+      },
+      beliefStatus: forkBeliefStatus,
+      sourceType: parent.sourceType,
+      confidence: void 0,
+      tupleContradicted: false,
+      verificationStatus: "unverified",
+      status: "active",
+      projectId: parent.projectId,
+      topicId: parent.topicId,
+      createdBy: authenticatedUserId,
+      createdAt: now,
+      updatedAt: now
+    });
+    const inheritedContracts = await ctx.db.query("epistemicContracts").withIndex(
+      "by_belief",
+      (q) => q.eq("beliefNodeId", args.parentNodeId)
+    ).collect();
+    for (const contract of inheritedContracts) {
+      if (contract.status === "archived") {
+        continue;
+      }
+      await ctx.db.insert(
+        "epistemicContracts",
+        createInheritedContractRecord(contract, {
+          beliefNodeId: newNodeId,
+          topicId: parent.topicId,
+          createdBy: authenticatedUserId,
+          now
+        })
+      );
+    }
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: newNodeId,
+      operation: "upsert"
+    });
+    await ctx.scheduler.runAfter(5e3, internal.neo4jEdgeAPI.createEdge, {
+      globalId: generateGlobalId(),
+      fromGlobalId: newBeliefGlobalId,
+      toGlobalId: parent.globalId,
+      edgeType: "supersedes",
+      context: `Fork reason: ${args.forkReason}`,
+      createdBy: authenticatedUserId,
+      topicId: parent.projectId ? String(parent.projectId) : void 0,
+      fromNodeType: "belief",
+      toNodeType: "belief"
+    });
+    await scheduleEmbeddingGeneration({
+      ctx,
+      nodeId: newNodeId,
+      projectId: parent.projectId,
+      topicId: parent.topicId,
+      createdBy: authenticatedUserId,
+      nodeType: "belief",
+      text: args.newFormulation
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "belief",
+      entityId: newNodeId,
+      changeType: "forked",
+      changedAt: now,
+      changedBy: authenticatedUserId,
+      isAgent: false,
+      previousState: {
+        parentNodeId: args.parentNodeId,
+        formulation: parent.canonicalText
+      },
+      newState: {
+        formulation: args.newFormulation,
+        forkReason: args.forkReason,
+        tupleContradicted: false
+      },
+      projectId: parent.projectId,
+      topicId: parent.topicId
+    });
+    if (parent.projectId || parent.topicId) {
+      const inheritedPillar = normalizePillar(
+        String(metadata?.pillar || metadata?.topic || "")
+      );
+      if (inheritedPillar === "other") {
+        await ctx.scheduler.runAfter(
+          2500,
+          "beliefCategorization:autoCategorizeBelief",
+          {
+            nodeId: newNodeId,
+            projectId: parent.projectId,
+            topicId: parent.topicId
+          }
+        );
+      }
+      await ctx.scheduler.runAfter(
+        3e3,
+        internal.beliefTemporalClassifier.classifyBelief,
+        {
+          nodeId: newNodeId,
+          projectId: parent.projectId,
+          topicId: parent.topicId
+        }
+      );
+    }
+    await markBeliefGraphDirty(ctx, {
+      projectId: parent.projectId,
+      topicId: parent.topicId
+    });
+    return { newNodeId, parentNodeId: args.parentNodeId };
+  }
+});
+
+export { create, forkBelief, getById, getByProject, getByTopic, refineBelief };
+//# sourceMappingURL=epistemicBeliefs.core.js.map
+//# sourceMappingURL=epistemicBeliefs.core.js.map