@lucern/graph-primitives 1.0.0 → 1.0.1

package/dist/epistemicNodes.js

@@ -4,7 +4,105 @@ import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
 import { componentsGeneric, anyApi, queryGeneric, mutationGeneric, internalMutationGeneric, internalQueryGeneric } from 'convex/server';
 import { isNodeType, getLayerForNodeType } from '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
 
-// src/epistemicNodes.ts
+// src/epistemicNodes.validators.ts
+var epistemicLayerValidator = v.union(
+  v.literal("L4"),
+  v.literal("L3"),
+  v.literal("L2"),
+  v.literal("L1"),
+  v.literal("ontological"),
+  v.literal("organizational")
+);
+var l4NodeTypeValidator = v.union(v.literal("decision"));
+var l3NodeTypeValidator = v.union(
+  v.literal("belief"),
+  v.literal("question"),
+  v.literal("theme"),
+  v.literal("deal")
+);
+var l2NodeTypeValidator = v.union(
+  v.literal("claim"),
+  v.literal("evidence"),
+  v.literal("synthesis")
+);
+var l1NodeTypeValidator = v.union(
+  v.literal("atomic_fact"),
+  v.literal("excerpt"),
+  v.literal("source")
+);
+var epistemicNodeTypeValidator = v.union(
+  // L4: Audit targets
+  v.literal("decision"),
+  // L3: Traversal anchors
+  v.literal("belief"),
+  v.literal("question"),
+  v.literal("theme"),
+  v.literal("deal"),
+  // L2: Compression boundary
+  v.literal("claim"),
+  v.literal("evidence"),
+  v.literal("synthesis"),
+  v.literal("answer"),
+  // L1: Terminal leaves
+  v.literal("atomic_fact"),
+  v.literal("excerpt"),
+  v.literal("source")
+);
+var ontologicalNodeTypeValidator = v.union(
+  v.literal("company"),
+  v.literal("person"),
+  v.literal("investor"),
+  v.literal("function"),
+  v.literal("value_chain")
+);
+var organizationalNodeTypeValidator = v.union(v.literal("topic"));
+var nodeTypeValidator = v.union(
+  // L4: Audit targets
+  v.literal("decision"),
+  // L3: Traversal anchors
+  v.literal("belief"),
+  v.literal("question"),
+  v.literal("theme"),
+  v.literal("deal"),
+  // L2: Compression boundary
+  v.literal("claim"),
+  v.literal("evidence"),
+  v.literal("synthesis"),
+  v.literal("answer"),
+  // L1: Terminal leaves
+  v.literal("atomic_fact"),
+  v.literal("excerpt"),
+  v.literal("source"),
+  // Ontological
+  v.literal("company"),
+  v.literal("person"),
+  v.literal("investor"),
+  v.literal("function"),
+  v.literal("value_chain"),
+  // Organizational
+  v.literal("topic")
+);
+var sourceTypeValidator = v.union(
+  v.literal("human"),
+  v.literal("ai_extracted"),
+  v.literal("ai_generated"),
+  v.literal("imported"),
+  v.literal("system")
+  // System-generated (migrations, classifiers)
+);
+var statusValidator = v.union(
+  v.literal("active"),
+  v.literal("superseded"),
+  v.literal("archived"),
+  v.literal("deleted")
+);
+var verificationStatusValidator = v.union(
+  v.literal("unverified"),
+  v.literal("human_verified"),
+  v.literal("ai_verified"),
+  v.literal("contradicted"),
+  v.literal("outdated")
+);
 var api = anyApi;
 componentsGeneric();
 var internal = anyApi;
@@ -24,344 +122,80 @@ function debugGraphPrimitiveFallback(message, context) {
   }
   console.debug(message, context ?? {});
 }
-
-// src/graphTypes.ts
-function getNodeLayer(nodeType) {
-  const L4_TYPES = ["decision"];
-  const L3_TYPES = ["belief", "question", "theme", "deal"];
-  const L2_TYPES = ["claim", "evidence", "synthesis", "answer"];
-  const L1_TYPES = ["atomic_fact", "excerpt", "source"];
-  const ONTOLOGICAL_TYPES = [
-    "company",
-    "person",
-    "investor",
-    "function",
-    "value_chain"
-  ];
-  const ORGANIZATIONAL_TYPES = ["topic"];
-  if (L4_TYPES.includes(nodeType)) {
-    return "L4";
-  }
-  if (L3_TYPES.includes(nodeType)) {
-    return "L3";
-  }
-  if (L2_TYPES.includes(nodeType)) {
-    return "L2";
-  }
-  if (L1_TYPES.includes(nodeType)) {
-    return "L1";
-  }
-  if (ONTOLOGICAL_TYPES.includes(nodeType)) {
-    return "ontological";
+var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
+function asMappedProjectId(topic) {
+  if (!topic) {
+    return;
   }
-  if (ORGANIZATIONAL_TYPES.includes(nodeType)) {
-    return "organizational";
+  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
   }
-  console.warn(`[GraphTypes] Unknown nodeType "${nodeType}", defaulting to L2`);
-  return "L2";
+  const metadata = topic.metadata || {};
+  const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
+  return candidate ? candidate : void 0;
 }
-
-// src/beliefLifecycle.ts
-var RESOLVED_PREDICTION_OUTCOMES = [
-  "confirmed",
-  "disconfirmed",
-  "partial",
-  "expired"
-];
-function hasResolvedPredictionOutcome(predictionMeta) {
-  if (!predictionMeta || typeof predictionMeta !== "object") {
-    return false;
+function normalizeScopeValue(value) {
+  if (typeof value !== "string") {
+    return;
   }
-  const outcome = predictionMeta.outcome;
-  return typeof outcome === "string" && RESOLVED_PREDICTION_OUTCOMES.includes(outcome);
-}
-
-// src/invariantEnforcement.ts
-var FORBIDDEN_GENERIC_BELIEF_METADATA_KEYS = /* @__PURE__ */ new Set([
-  "beliefStatus",
-  "epistemicStatus",
-  "forkedBy",
-  "forkedFrom",
-  "forkReason",
-  "forkTimestamp",
-  "status",
-  "supersededBy",
-  "supersedes"
-]);
-var ONTOLOGICAL_NODE_TYPES = /* @__PURE__ */ new Set([
-  "company",
-  "person",
-  "investor",
-  "function",
-  "value_chain"
-]);
-function throwInvariantError(args) {
-  const error = new Error(args.message);
-  error.status = args.status ?? 409;
-  error.code = args.code ?? "INVARIANT_VIOLATION";
-  error.invariantCode = args.invariantCode;
-  error.suggestion = args.suggestion;
-  error.details = args.details;
-  throw error;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
 }
-function isBeliefNode(node) {
-  return node?.nodeType === "belief";
+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];
 }
-function isOntologicalNode(node) {
-  return typeof node?.nodeType === "string" && ONTOLOGICAL_NODE_TYPES.has(node.nodeType);
+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;
+    });
+  }
 }
-function isScoredBeliefNode(node) {
-  if (!isBeliefNode(node)) {
-    return false;
+async function tryResolveHostTopicById(ctx, topicId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
   }
-  const metadata = node.metadata && typeof node.metadata === "object" ? node.metadata : void 0;
-  const numericConfidence = typeof node.confidence === "number" && Number.isFinite(node.confidence);
-  if (numericConfidence) {
-    return true;
-  }
-  return hasResolvedPredictionOutcome(node.predictionMeta) || hasResolvedPredictionOutcome(metadata?.predictionMeta);
-}
-function getForbiddenMetadataKeys(metadata) {
-  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
-    return [];
-  }
-  return Object.keys(metadata).filter(
-    (key) => FORBIDDEN_GENERIC_BELIEF_METADATA_KEYS.has(key)
-  );
-}
-function assertBeliefNodeGenericUpdateAllowed(args) {
-  if (!isBeliefNode(args.node)) {
-    return;
-  }
-  if (Object.hasOwn(args.updates, "confidence")) {
-    throwInvariantError({
-      message: "Belief confidence is append-only. Generic node updates cannot set confidence directly.",
-      invariantCode: "belief.confidence_append_only",
-      suggestion: "Use epistemicBeliefs.modulateConfidence() so the beliefConfidence ledger and audit trail are updated together.",
-      details: { mutationName: args.mutationName, nodeId: args.node._id }
-    });
-  }
-  if (Object.hasOwn(args.updates, "status")) {
-    throwInvariantError({
-      message: "Belief status transitions must use the dedicated belief lifecycle APIs.",
-      invariantCode: "belief.status_transition_requires_belief_api",
-      suggestion: "Use epistemicBeliefs.updateStatus() or epistemicBeliefs.archive() so status transitions emit the correct audit event.",
-      details: { mutationName: args.mutationName, nodeId: args.node._id }
-    });
-  }
-  const forbiddenMetadataKeys = getForbiddenMetadataKeys(args.updates.metadata);
-  if (forbiddenMetadataKeys.length > 0) {
-    throwInvariantError({
-      message: "Belief lineage and lifecycle metadata cannot be rewritten through generic node updates.",
-      invariantCode: "belief.lineage_requires_fork_belief",
-      suggestion: "Use epistemicBeliefs.forkBelief() for lineage changes and dedicated belief lifecycle mutations for status changes.",
-      details: {
-        mutationName: args.mutationName,
-        nodeId: args.node._id,
-        forbiddenMetadataKeys
-      }
-    });
-  }
-  if (isScoredBeliefNode(args.node) && (Object.hasOwn(args.updates, "canonicalText") || Object.hasOwn(args.updates, "contentHash"))) {
-    throwInvariantError({
-      message: "Cannot refine a scored belief in place. Scored formulations are immutable.",
-      invariantCode: "belief.formulation_immutable_after_scoring",
-      suggestion: "Use epistemicBeliefs.forkBelief() to evolve the formulation while preserving lineage.",
-      details: { mutationName: args.mutationName, nodeId: args.node._id }
-    });
-  }
-}
-function assertBeliefNodeArchiveAllowed(args) {
-  if (!isBeliefNode(args.node)) {
-    return;
-  }
-  throwInvariantError({
-    message: "Belief archiving must go through the dedicated belief lifecycle API.",
-    invariantCode: "belief.status_transition_requires_belief_api",
-    suggestion: "Use epistemicBeliefs.archive() so the belief lifecycle audit trail stays consistent.",
-    details: { mutationName: args.mutationName, nodeId: args.node._id }
-  });
-}
-function assertBeliefNodeVerifyAllowed(args) {
-  if (!isBeliefNode(args.node) || args.confidence === void 0) {
-    return;
-  }
-  throwInvariantError({
-    message: "Belief verification cannot set confidence directly. Confidence changes must stay append-only.",
-    invariantCode: "belief.confidence_append_only",
-    suggestion: "Call epistemicBeliefs.modulateConfidence() after verification so the confidence history is preserved.",
-    details: { mutationName: args.mutationName, nodeId: args.node._id }
-  });
-}
-function assertBeliefNodeSupersedeAllowed(args) {
-  if (!isBeliefNode(args.node)) {
-    return;
-  }
-  throwInvariantError({
-    message: "Belief lineage changes must use forkBelief(), not the generic supersede path.",
-    invariantCode: "belief.lineage_requires_fork_belief",
-    suggestion: "Use epistemicBeliefs.forkBelief() so the child belief, supersedes edge, and audit trail are created together.",
-    details: { mutationName: args.mutationName, nodeId: args.node._id }
-  });
-}
-function assertBeliefNodeHardDeleteAllowed(args) {
-  if (!isBeliefNode(args.node)) {
-    return;
-  }
-  if (!args.allowBeliefHardDelete) {
-    throwInvariantError({
-      message: "Belief hard delete is forbidden by default. Beliefs must retain lineage and audit history.",
-      invariantCode: "belief.hard_delete_forbidden",
-      suggestion: "Use epistemicBeliefs.archive() or epistemicBeliefs.forkBelief() instead. Only migration repair flows may opt into hard delete explicitly.",
-      details: { mutationName: args.mutationName, nodeId: args.node._id }
-    });
-  }
-  if (!args.reason.trim().toLowerCase().startsWith("migration:")) {
-    throwInvariantError({
-      message: "Belief hard delete bypasses require a migration-scoped rationale.",
-      invariantCode: "belief.hard_delete_forbidden",
-      suggestion: 'Retry with allowBeliefHardDelete: true and a reason starting with "migration:" only for one-off data repair flows.',
-      details: {
-        mutationName: args.mutationName,
-        nodeId: args.node._id,
-        reason: args.reason
-      }
-    });
-  }
-}
-function assertOntologicalNodeGenericCreateAllowed(args) {
-  if (!ONTOLOGICAL_NODE_TYPES.has(args.nodeType)) {
-    return;
-  }
-  throwInvariantError({
-    message: "Ontological entities must be created through the dedicated entity lifecycle API.",
-    invariantCode: "entity.create_requires_entity_lifecycle",
-    suggestion: "Use entityLifecycle.createEntity() so tenant-global canonical scope and deduplication are enforced.",
-    details: {
-      mutationName: args.mutationName,
-      nodeType: args.nodeType
-    }
-  });
-}
-function assertOntologicalNodeGenericUpdateAllowed(args) {
-  if (!isOntologicalNode(args.node)) {
-    return;
-  }
-  throwInvariantError({
-    message: "Ontological entities must be updated through the dedicated entity lifecycle API.",
-    invariantCode: "entity.update_requires_entity_lifecycle",
-    suggestion: "Use entityLifecycle.updateEntityAttributes() so canonical entity mutations stay type-safe and audited.",
-    details: {
-      mutationName: args.mutationName,
-      nodeId: args.node._id,
-      nodeType: args.node.nodeType
-    }
-  });
-}
-function assertOntologicalNodeArchiveAllowed(args) {
-  if (!isOntologicalNode(args.node)) {
-    return;
-  }
-  throwInvariantError({
-    message: "Ontological entities must be archived through the dedicated entity lifecycle API.",
-    invariantCode: "entity.archive_requires_entity_lifecycle",
-    suggestion: "Use entityLifecycle.archiveEntity() so entity archival emits the correct audit trail and review hooks.",
-    details: {
-      mutationName: args.mutationName,
-      nodeId: args.node._id,
-      nodeType: args.node.nodeType
-    }
-  });
-}
-function assertOntologicalNodeSupersedeAllowed(args) {
-  if (!isOntologicalNode(args.node)) {
-    return;
-  }
-  throwInvariantError({
-    message: "Ontological entities do not use the generic supersede path.",
-    invariantCode: "entity.supersede_requires_entity_lifecycle",
-    suggestion: "Use entityLifecycle.updateEntityAttributes() to edit an entity in place or entityLifecycle.mergeEntities() to collapse duplicates.",
-    details: {
-      mutationName: args.mutationName,
-      nodeId: args.node._id,
-      nodeType: args.node.nodeType
-    }
-  });
-}
-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;
+  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) {
@@ -511,176 +345,78 @@ var optionalScopeArgs = {
   projectId: v.optional(v.string()),
   topicId: v.optional(v.string())
 };
-function normalizeScopeValue2(value) {
-  if (typeof value !== "string") {
-    return;
+
+// src/epistemicNodes.helpers.ts
+var DEFAULT_NODE_PAGE_SIZE = 250;
+var MAX_NODE_PAGE_SIZE = 8e3;
+function clampNodeLimit(limit, fallback = DEFAULT_NODE_PAGE_SIZE) {
+  if (!Number.isFinite(limit)) {
+    return fallback;
   }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : void 0;
+  return Math.max(1, Math.min(Math.floor(limit), MAX_NODE_PAGE_SIZE));
 }
-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 buildNodeStatusSuccessResult() {
+  return { success: true };
 }
-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 buildNodeArchivedResult() {
+  return {
+    success: true,
+    effectiveStatus: "archived"
+  };
 }
-function resolveRuntimePackMutationContext(args) {
-  if (!args.runtimeToolName && !args.runtimePackKey && !args.runtimePackInstallScope) {
-    return;
-  }
+function buildNodeNotFoundResult() {
+  const result = {};
+  result.success = false;
+  result.error = "Node not found";
+  return result;
+}
+function buildNodeDeletedResult(deletedEdgeCount) {
   return {
-    toolName: args.runtimeToolName,
-    packKey: args.runtimePackKey,
-    packInstallScope: args.runtimePackInstallScope
+    success: true,
+    deletedEdgeCount
   };
 }
-function assertTenantPackWorkspaceMutationAllowed(args) {
-  if (!args.runtime?.packKey || args.runtime.packInstallScope !== "tenant") {
-    return;
+function dedupeWorkspaceNodes(nodes) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const node of nodes) {
+    const key = String(node._id);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(node);
   }
-  const targetWorkspaceId = normalizeScopeValue2(args.target.workspaceId);
-  const targetLayer = typeof args.target.epistemicLayer === "string" ? args.target.epistemicLayer : void 0;
-  if (!targetWorkspaceId || targetLayer === "ontological") {
-    return;
+  return deduped;
+}
+function nodeMatchesWorkspaceReasoningScope(node, scope) {
+  return scope.topicId !== void 0 && node.topicId === scope.topicId || scope.projectId !== void 0 && node.projectId === scope.projectId;
+}
+async function collectScopedNodes(ctx, scope, args) {
+  const queries = [];
+  if (scope.topicId) {
+    queries.push(
+      args.nodeType ? ctx.db.query("epistemicNodes").withIndex(
+        "by_topic_type",
+        (q) => q.eq("topicId", scope.topicId).eq("nodeType", args.nodeType)
+      ).order("desc").take(args.scanLimit) : ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", scope.topicId)).order("desc").take(args.scanLimit)
+    );
   }
-  throwWorkspaceIsolationError({
-    message: `Tenant-scoped pack "${args.runtime.packKey}" cannot mutate workspace-scoped reasoning state.`,
-    invariantCode: "workspace.tenant_pack_reasoning_write_forbidden",
-    suggestion: "Use a workspace-scoped pack for workspace-local graph mutations, or route the change through tenant-global canonical entity flows.",
-    details: {
-      mutationName: args.mutationName,
-      toolName: args.runtime.toolName,
-      packKey: args.runtime.packKey,
-      targetWorkspaceId,
-      targetNodeType: args.target.nodeType,
-      targetLayer
-    }
-  });
+  if (scope.projectId && !scope.topicId) {
+    queries.push(
+      args.nodeType ? ctx.db.query("epistemicNodes").withIndex(
+        "by_topic_type",
+        (q) => q.eq("topicId", scope.projectId).eq("nodeType", args.nodeType)
+      ).order("desc").take(args.scanLimit) : ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", scope.projectId)).order("desc").take(args.scanLimit)
+    );
+  }
+  const combined = dedupeWorkspaceNodes((await Promise.all(queries)).flat());
+  return combined.filter(
+    (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
+  );
 }
 
-// src/epistemicNodes.ts
-var epistemicLayerValidator = v.union(
-  v.literal("L4"),
-  v.literal("L3"),
-  v.literal("L2"),
-  v.literal("L1"),
-  v.literal("ontological"),
-  v.literal("organizational")
-);
-var l4NodeTypeValidator = v.union(v.literal("decision"));
-var l3NodeTypeValidator = v.union(
-  v.literal("belief"),
-  v.literal("question"),
-  v.literal("theme"),
-  v.literal("deal")
-);
-var l2NodeTypeValidator = v.union(
-  v.literal("claim"),
-  v.literal("evidence"),
-  v.literal("synthesis")
-);
-var l1NodeTypeValidator = v.union(
-  v.literal("atomic_fact"),
-  v.literal("excerpt"),
-  v.literal("source")
-);
-var epistemicNodeTypeValidator = v.union(
-  // L4: Audit targets
-  v.literal("decision"),
-  // L3: Traversal anchors
-  v.literal("belief"),
-  v.literal("question"),
-  v.literal("theme"),
-  v.literal("deal"),
-  // L2: Compression boundary
-  v.literal("claim"),
-  v.literal("evidence"),
-  v.literal("synthesis"),
-  v.literal("answer"),
-  // L1: Terminal leaves
-  v.literal("atomic_fact"),
-  v.literal("excerpt"),
-  v.literal("source")
-);
-var ontologicalNodeTypeValidator = v.union(
-  v.literal("company"),
-  v.literal("person"),
-  v.literal("investor"),
-  v.literal("function"),
-  v.literal("value_chain")
-);
-var organizationalNodeTypeValidator = v.union(v.literal("topic"));
-var nodeTypeValidator = v.union(
-  // L4: Audit targets
-  v.literal("decision"),
-  // L3: Traversal anchors
-  v.literal("belief"),
-  v.literal("question"),
-  v.literal("theme"),
-  v.literal("deal"),
-  // L2: Compression boundary
-  v.literal("claim"),
-  v.literal("evidence"),
-  v.literal("synthesis"),
-  v.literal("answer"),
-  // L1: Terminal leaves
-  v.literal("atomic_fact"),
-  v.literal("excerpt"),
-  v.literal("source"),
-  // Ontological
-  v.literal("company"),
-  v.literal("person"),
-  v.literal("investor"),
-  v.literal("function"),
-  v.literal("value_chain"),
-  // Organizational
-  v.literal("topic")
-);
-var sourceTypeValidator = v.union(
-  v.literal("human"),
-  v.literal("ai_extracted"),
-  v.literal("ai_generated"),
-  v.literal("imported"),
-  v.literal("system")
-  // System-generated (migrations, classifiers)
-);
-var statusValidator = v.union(
-  v.literal("active"),
-  v.literal("superseded"),
-  v.literal("archived"),
-  v.literal("deleted")
-);
-var verificationStatusValidator = v.union(
-  v.literal("unverified"),
-  v.literal("human_verified"),
-  v.literal("ai_verified"),
-  v.literal("contradicted"),
-  v.literal("outdated")
-);
+// src/epistemicNodes.queries.ts
 var optionalNodeScopeArgs = optionalScopeArgs;
 var get = query({
   args: { nodeId: v.id("epistemicNodes") },
@@ -798,85 +534,17 @@ var getByProjectAndTypeLite = query({
     }));
   }
 });
-var DEFAULT_NODE_PAGE_SIZE = 250;
-var MAX_NODE_PAGE_SIZE = 8e3;
-function clampNodeLimit(limit, fallback = DEFAULT_NODE_PAGE_SIZE) {
-  if (!Number.isFinite(limit)) {
-    return fallback;
-  }
-  return Math.max(1, Math.min(Math.floor(limit), MAX_NODE_PAGE_SIZE));
-}
-function buildNodeStatusSuccessResult() {
-  return { success: true };
-}
-function buildNodeArchivedResult() {
-  return {
-    success: true,
-    effectiveStatus: "archived"
-  };
-}
-function buildNodeNotFoundResult() {
-  const result = {};
-  result.success = false;
-  result.error = "Node not found";
-  return result;
-}
-function buildNodeDeletedResult(deletedEdgeCount) {
-  return {
-    success: true,
-    deletedEdgeCount
-  };
-}
-function dedupeWorkspaceNodes(nodes) {
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const node of nodes) {
-    const key = String(node._id);
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    deduped.push(node);
-  }
-  return deduped;
-}
-function nodeMatchesWorkspaceReasoningScope(node, scope) {
-  return scope.topicId !== void 0 && node.topicId === scope.topicId || scope.projectId !== void 0 && node.projectId === scope.projectId;
-}
-async function collectScopedNodes(ctx, scope, args) {
-  const queries = [];
-  if (scope.topicId) {
-    queries.push(
-      args.nodeType ? ctx.db.query("epistemicNodes").withIndex(
-        "by_topic_type",
-        (q) => q.eq("topicId", scope.topicId).eq("nodeType", args.nodeType)
-      ).order("desc").take(args.scanLimit) : ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", scope.topicId)).order("desc").take(args.scanLimit)
-    );
-  }
-  if (scope.projectId && !scope.topicId) {
-    queries.push(
-      args.nodeType ? ctx.db.query("epistemicNodes").withIndex(
-        "by_topic_type",
-        (q) => q.eq("topicId", scope.projectId).eq("nodeType", args.nodeType)
-      ).order("desc").take(args.scanLimit) : ctx.db.query("epistemicNodes").withIndex("by_topic", (q) => q.eq("topicId", scope.projectId)).order("desc").take(args.scanLimit)
-    );
-  }
-  const combined = dedupeWorkspaceNodes((await Promise.all(queries)).flat());
-  return combined.filter(
-    (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
-  );
-}
-var getByProject = query({
-  args: {
-    ...optionalNodeScopeArgs,
-    userId: v.optional(v.string()),
-    includeArchived: v.optional(v.boolean()),
-    limit: v.optional(v.number())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    if (!args.projectId && !args.topicId) {
-      return [];
+var getByProject = query({
+  args: {
+    ...optionalNodeScopeArgs,
+    userId: v.optional(v.string()),
+    includeArchived: v.optional(v.boolean()),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    if (!args.projectId && !args.topicId) {
+      return [];
     }
     const pageSize = clampNodeLimit(args.limit);
     const scanLimit = Math.min(pageSize * 3, MAX_NODE_PAGE_SIZE);
@@ -887,14 +555,11 @@ var getByProject = query({
         topicId: args.topicId
       });
     } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[epistemicNodes] Failed to resolve list scope",
-        {
-          error,
-          projectId: args.projectId,
-          topicId: args.topicId
-        }
-      );
+      debugGraphPrimitiveFallback("[epistemicNodes] Failed to resolve list scope", {
+        error,
+        projectId: args.projectId,
+        topicId: args.topicId
+      });
       return [];
     }
     if (args.userId) {
@@ -907,74 +572,410 @@ var getByProject = query({
         return [];
       }
     }
-    const nodes = await collectScopedNodes(ctx, scope, { scanLimit });
-    if (args.includeArchived) {
-      return nodes.filter(
-        (n) => n.status !== "deleted" && nodeMatchesWorkspaceReasoningScope(n, scope)
-      ).slice(0, pageSize);
+    const nodes = await collectScopedNodes(ctx, scope, { scanLimit });
+    if (args.includeArchived) {
+      return nodes.filter(
+        (n) => n.status !== "deleted" && nodeMatchesWorkspaceReasoningScope(n, scope)
+      ).slice(0, pageSize);
+    }
+    return nodes.filter(
+      (n) => n.status === "active" && nodeMatchesWorkspaceReasoningScope(n, scope)
+    ).slice(0, pageSize);
+  }
+});
+var listAll = query({
+  args: {
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const pageSize = clampNodeLimit(args.limit ?? 2e3);
+    const scanLimit = Math.min(pageSize * 2, MAX_NODE_PAGE_SIZE * 2);
+    const nodes = await ctx.db.query("epistemicNodes").order("desc").take(scanLimit);
+    return nodes.filter((n) => n.status === "active").slice(0, pageSize);
+  }
+});
+var search = query({
+  args: {
+    searchQuery: v.string(),
+    ...optionalNodeScopeArgs,
+    nodeType: v.optional(nodeTypeValidator),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const pageSize = clampNodeLimit(args.limit, 100);
+    let scope;
+    if (args.projectId || args.topicId) {
+      try {
+        scope = await resolveTopicProjectScope(ctx, {
+          projectId: args.projectId,
+          topicId: args.topicId
+        });
+      } catch (error) {
+        debugGraphPrimitiveFallback(
+          "[epistemicNodes] Failed to resolve search scope",
+          {
+            error,
+            projectId: args.projectId,
+            topicId: args.topicId
+          }
+        );
+        return [];
+      }
+    }
+    const searchResults = ctx.db.query("epistemicNodes").withSearchIndex("search_canonicalText", (q) => {
+      let search2 = q.search("canonicalText", args.searchQuery);
+      if (scope?.topicId) {
+        search2 = search2.eq("topicId", scope.topicId);
+      } else if (scope?.projectId) {
+        search2 = search2.eq("projectId", scope.projectId);
+      }
+      if (args.nodeType) {
+        search2 = search2.eq("nodeType", args.nodeType);
+      }
+      return search2.eq("status", "active");
+    });
+    return await searchResults.take(pageSize);
+  }
+});
+
+// src/graphTypes.ts
+function getNodeLayer(nodeType) {
+  const L4_TYPES = ["decision"];
+  const L3_TYPES = ["belief", "question", "theme", "deal"];
+  const L2_TYPES = ["claim", "evidence", "synthesis", "answer"];
+  const L1_TYPES = ["atomic_fact", "excerpt", "source"];
+  const ONTOLOGICAL_TYPES = [
+    "company",
+    "person",
+    "investor",
+    "function",
+    "value_chain"
+  ];
+  const ORGANIZATIONAL_TYPES = ["topic"];
+  if (L4_TYPES.includes(nodeType)) {
+    return "L4";
+  }
+  if (L3_TYPES.includes(nodeType)) {
+    return "L3";
+  }
+  if (L2_TYPES.includes(nodeType)) {
+    return "L2";
+  }
+  if (L1_TYPES.includes(nodeType)) {
+    return "L1";
+  }
+  if (ONTOLOGICAL_TYPES.includes(nodeType)) {
+    return "ontological";
+  }
+  if (ORGANIZATIONAL_TYPES.includes(nodeType)) {
+    return "organizational";
+  }
+  console.warn(`[GraphTypes] Unknown nodeType "${nodeType}", defaulting to L2`);
+  return "L2";
+}
+
+// src/beliefLifecycle.ts
+var RESOLVED_PREDICTION_OUTCOMES = [
+  "confirmed",
+  "disconfirmed",
+  "partial",
+  "expired"
+];
+function hasResolvedPredictionOutcome(predictionMeta) {
+  if (!predictionMeta || typeof predictionMeta !== "object") {
+    return false;
+  }
+  const outcome = predictionMeta.outcome;
+  return typeof outcome === "string" && RESOLVED_PREDICTION_OUTCOMES.includes(outcome);
+}
+
+// src/invariantEnforcement.ts
+var FORBIDDEN_GENERIC_BELIEF_METADATA_KEYS = /* @__PURE__ */ new Set([
+  "beliefStatus",
+  "epistemicStatus",
+  "forkedBy",
+  "forkedFrom",
+  "forkReason",
+  "forkTimestamp",
+  "status",
+  "supersededBy",
+  "supersedes"
+]);
+var ONTOLOGICAL_NODE_TYPES = /* @__PURE__ */ new Set([
+  "company",
+  "person",
+  "investor",
+  "function",
+  "value_chain"
+]);
+function throwInvariantError(args) {
+  const error = new Error(args.message);
+  error.status = args.status ?? 409;
+  error.code = args.code ?? "INVARIANT_VIOLATION";
+  error.invariantCode = args.invariantCode;
+  error.suggestion = args.suggestion;
+  error.details = args.details;
+  throw error;
+}
+function isBeliefNode(node) {
+  return node?.nodeType === "belief";
+}
+function isOntologicalNode(node) {
+  return typeof node?.nodeType === "string" && ONTOLOGICAL_NODE_TYPES.has(node.nodeType);
+}
+function isScoredBeliefNode(node) {
+  if (!isBeliefNode(node)) {
+    return false;
+  }
+  const metadata = node.metadata && typeof node.metadata === "object" ? node.metadata : void 0;
+  const numericConfidence = typeof node.confidence === "number" && Number.isFinite(node.confidence);
+  if (numericConfidence) {
+    return true;
+  }
+  return hasResolvedPredictionOutcome(node.predictionMeta) || hasResolvedPredictionOutcome(metadata?.predictionMeta);
+}
+function getForbiddenMetadataKeys(metadata) {
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+    return [];
+  }
+  return Object.keys(metadata).filter(
+    (key) => FORBIDDEN_GENERIC_BELIEF_METADATA_KEYS.has(key)
+  );
+}
+function assertBeliefNodeGenericUpdateAllowed(args) {
+  if (!isBeliefNode(args.node)) {
+    return;
+  }
+  if (Object.hasOwn(args.updates, "confidence")) {
+    throwInvariantError({
+      message: "Belief confidence is append-only. Generic node updates cannot set confidence directly.",
+      invariantCode: "belief.confidence_append_only",
+      suggestion: "Use epistemicBeliefs.modulateConfidence() so the beliefConfidence ledger and audit trail are updated together.",
+      details: { mutationName: args.mutationName, nodeId: args.node._id }
+    });
+  }
+  if (Object.hasOwn(args.updates, "status")) {
+    throwInvariantError({
+      message: "Belief status transitions must use the dedicated belief lifecycle APIs.",
+      invariantCode: "belief.status_transition_requires_belief_api",
+      suggestion: "Use epistemicBeliefs.updateStatus() or epistemicBeliefs.archive() so status transitions emit the correct audit event.",
+      details: { mutationName: args.mutationName, nodeId: args.node._id }
+    });
+  }
+  const forbiddenMetadataKeys = getForbiddenMetadataKeys(args.updates.metadata);
+  if (forbiddenMetadataKeys.length > 0) {
+    throwInvariantError({
+      message: "Belief lineage and lifecycle metadata cannot be rewritten through generic node updates.",
+      invariantCode: "belief.lineage_requires_fork_belief",
+      suggestion: "Use epistemicBeliefs.forkBelief() for lineage changes and dedicated belief lifecycle mutations for status changes.",
+      details: {
+        mutationName: args.mutationName,
+        nodeId: args.node._id,
+        forbiddenMetadataKeys
+      }
+    });
+  }
+  if (isScoredBeliefNode(args.node) && (Object.hasOwn(args.updates, "canonicalText") || Object.hasOwn(args.updates, "contentHash"))) {
+    throwInvariantError({
+      message: "Cannot refine a scored belief in place. Scored formulations are immutable.",
+      invariantCode: "belief.formulation_immutable_after_scoring",
+      suggestion: "Use epistemicBeliefs.forkBelief() to evolve the formulation while preserving lineage.",
+      details: { mutationName: args.mutationName, nodeId: args.node._id }
+    });
+  }
+}
+function assertBeliefNodeArchiveAllowed(args) {
+  if (!isBeliefNode(args.node)) {
+    return;
+  }
+  throwInvariantError({
+    message: "Belief archiving must go through the dedicated belief lifecycle API.",
+    invariantCode: "belief.status_transition_requires_belief_api",
+    suggestion: "Use epistemicBeliefs.archive() so the belief lifecycle audit trail stays consistent.",
+    details: { mutationName: args.mutationName, nodeId: args.node._id }
+  });
+}
+function assertBeliefNodeVerifyAllowed(args) {
+  if (!isBeliefNode(args.node) || args.confidence === void 0) {
+    return;
+  }
+  throwInvariantError({
+    message: "Belief verification cannot set confidence directly. Confidence changes must stay append-only.",
+    invariantCode: "belief.confidence_append_only",
+    suggestion: "Call epistemicBeliefs.modulateConfidence() after verification so the confidence history is preserved.",
+    details: { mutationName: args.mutationName, nodeId: args.node._id }
+  });
+}
+function assertBeliefNodeSupersedeAllowed(args) {
+  if (!isBeliefNode(args.node)) {
+    return;
+  }
+  throwInvariantError({
+    message: "Belief lineage changes must use forkBelief(), not the generic supersede path.",
+    invariantCode: "belief.lineage_requires_fork_belief",
+    suggestion: "Use epistemicBeliefs.forkBelief() so the child belief, supersedes edge, and audit trail are created together.",
+    details: { mutationName: args.mutationName, nodeId: args.node._id }
+  });
+}
+function assertBeliefNodeHardDeleteAllowed(args) {
+  if (!isBeliefNode(args.node)) {
+    return;
+  }
+  if (!args.allowBeliefHardDelete) {
+    throwInvariantError({
+      message: "Belief hard delete is forbidden by default. Beliefs must retain lineage and audit history.",
+      invariantCode: "belief.hard_delete_forbidden",
+      suggestion: "Use epistemicBeliefs.archive() or epistemicBeliefs.forkBelief() instead. Only migration repair flows may opt into hard delete explicitly.",
+      details: { mutationName: args.mutationName, nodeId: args.node._id }
+    });
+  }
+  if (!args.reason.trim().toLowerCase().startsWith("migration:")) {
+    throwInvariantError({
+      message: "Belief hard delete bypasses require a migration-scoped rationale.",
+      invariantCode: "belief.hard_delete_forbidden",
+      suggestion: 'Retry with allowBeliefHardDelete: true and a reason starting with "migration:" only for one-off data repair flows.',
+      details: {
+        mutationName: args.mutationName,
+        nodeId: args.node._id,
+        reason: args.reason
+      }
+    });
+  }
+}
+function assertOntologicalNodeGenericCreateAllowed(args) {
+  if (!ONTOLOGICAL_NODE_TYPES.has(args.nodeType)) {
+    return;
+  }
+  throwInvariantError({
+    message: "Ontological entities must be created through the dedicated entity lifecycle API.",
+    invariantCode: "entity.create_requires_entity_lifecycle",
+    suggestion: "Use entityLifecycle.createEntity() so tenant-global canonical scope and deduplication are enforced.",
+    details: {
+      mutationName: args.mutationName,
+      nodeType: args.nodeType
+    }
+  });
+}
+function assertOntologicalNodeGenericUpdateAllowed(args) {
+  if (!isOntologicalNode(args.node)) {
+    return;
+  }
+  throwInvariantError({
+    message: "Ontological entities must be updated through the dedicated entity lifecycle API.",
+    invariantCode: "entity.update_requires_entity_lifecycle",
+    suggestion: "Use entityLifecycle.updateEntityAttributes() so canonical entity mutations stay type-safe and audited.",
+    details: {
+      mutationName: args.mutationName,
+      nodeId: args.node._id,
+      nodeType: args.node.nodeType
+    }
+  });
+}
+function assertOntologicalNodeArchiveAllowed(args) {
+  if (!isOntologicalNode(args.node)) {
+    return;
+  }
+  throwInvariantError({
+    message: "Ontological entities must be archived through the dedicated entity lifecycle API.",
+    invariantCode: "entity.archive_requires_entity_lifecycle",
+    suggestion: "Use entityLifecycle.archiveEntity() so entity archival emits the correct audit trail and review hooks.",
+    details: {
+      mutationName: args.mutationName,
+      nodeId: args.node._id,
+      nodeType: args.node.nodeType
+    }
+  });
+}
+function assertOntologicalNodeSupersedeAllowed(args) {
+  if (!isOntologicalNode(args.node)) {
+    return;
+  }
+  throwInvariantError({
+    message: "Ontological entities do not use the generic supersede path.",
+    invariantCode: "entity.supersede_requires_entity_lifecycle",
+    suggestion: "Use entityLifecycle.updateEntityAttributes() to edit an entity in place or entityLifecycle.mergeEntities() to collapse duplicates.",
+    details: {
+      mutationName: args.mutationName,
+      nodeId: args.node._id,
+      nodeType: args.node.nodeType
     }
-    return nodes.filter(
-      (n) => n.status === "active" && nodeMatchesWorkspaceReasoningScope(n, scope)
-    ).slice(0, pageSize);
+  });
+}
+function normalizeScopeValue2(value) {
+  if (typeof value !== "string") {
+    return;
   }
-});
-var getByTopic = getByProject;
-var listAll = query({
-  args: {
-    limit: v.optional(v.number())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const pageSize = clampNodeLimit(args.limit ?? 2e3);
-    const scanLimit = Math.min(pageSize * 2, MAX_NODE_PAGE_SIZE * 2);
-    const nodes = await ctx.db.query("epistemicNodes").order("desc").take(scanLimit);
-    return nodes.filter((n) => n.status === "active").slice(0, pageSize);
+  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;
   }
-});
-var search = query({
-  args: {
-    searchQuery: v.string(),
-    ...optionalNodeScopeArgs,
-    nodeType: v.optional(nodeTypeValidator),
-    limit: v.optional(v.number())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const pageSize = clampNodeLimit(args.limit, 100);
-    let scope;
-    if (args.projectId || args.topicId) {
-      try {
-        scope = await resolveTopicProjectScope(ctx, {
-          projectId: args.projectId,
-          topicId: args.topicId
-        });
-      } catch (error) {
-        debugGraphPrimitiveFallback(
-          "[epistemicNodes] Failed to resolve search scope",
-          {
-            error,
-            projectId: args.projectId,
-            topicId: args.topicId
-          }
-        );
-        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
     }
-    const searchResults = ctx.db.query("epistemicNodes").withSearchIndex("search_canonicalText", (q) => {
-      let search2 = q.search("canonicalText", args.searchQuery);
-      if (scope?.topicId) {
-        search2 = search2.eq("topicId", scope.topicId);
-      } else if (scope?.projectId) {
-        search2 = search2.eq("projectId", scope.projectId);
-      }
-      if (args.nodeType) {
-        search2 = search2.eq("nodeType", args.nodeType);
-      }
-      return search2.eq("status", "active");
-    });
-    return await searchResults.take(pageSize);
+  });
+}
+function resolveRuntimePackMutationContext(args) {
+  if (!args.runtimeToolName && !args.runtimePackKey && !args.runtimePackInstallScope) {
+    return;
   }
-});
+  return {
+    toolName: args.runtimeToolName,
+    packKey: args.runtimePackKey,
+    packInstallScope: args.runtimePackInstallScope
+  };
+}
+function assertTenantPackWorkspaceMutationAllowed(args) {
+  if (!args.runtime?.packKey || args.runtime.packInstallScope !== "tenant") {
+    return;
+  }
+  const targetWorkspaceId = normalizeScopeValue2(args.target.workspaceId);
+  const targetLayer = typeof args.target.epistemicLayer === "string" ? args.target.epistemicLayer : void 0;
+  if (!targetWorkspaceId || targetLayer === "ontological") {
+    return;
+  }
+  throwWorkspaceIsolationError({
+    message: `Tenant-scoped pack "${args.runtime.packKey}" cannot mutate workspace-scoped reasoning state.`,
+    invariantCode: "workspace.tenant_pack_reasoning_write_forbidden",
+    suggestion: "Use a workspace-scoped pack for workspace-local graph mutations, or route the change through tenant-global canonical entity flows.",
+    details: {
+      mutationName: args.mutationName,
+      toolName: args.runtime.toolName,
+      packKey: args.runtime.packKey,
+      targetWorkspaceId,
+      targetNodeType: args.target.nodeType,
+      targetLayer
+    }
+  });
+}
+
+// src/epistemicNodes.mutations.ts
+var optionalNodeScopeArgs2 = optionalScopeArgs;
 var create = mutation({
   args: {
     globalId: v.string(),
@@ -1004,7 +1005,7 @@ var create = mutation({
     extractedFromNodeId: v.optional(v.id("epistemicNodes")),
     confidence: v.optional(v.number()),
     verificationStatus: v.optional(verificationStatusValidator),
-    ...optionalNodeScopeArgs,
+    ...optionalNodeScopeArgs2,
     createdBy: v.string(),
     runtimeToolName: v.optional(v.string()),
     runtimePackKey: v.optional(v.string()),
@@ -1308,56 +1309,6 @@ var archive = mutation({
     return buildNodeArchivedResult();
   }
 });
-var hardDelete = internalMutation({
-  args: {
-    nodeId: v.id("epistemicNodes"),
-    reason: v.string(),
-    // Required: document why this is being hard-deleted
-    allowBeliefHardDelete: v.optional(v.boolean())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.nodeId);
-    if (!node) {
-      return buildNodeNotFoundResult();
-    }
-    assertBeliefNodeHardDeleteAllowed({
-      node,
-      allowBeliefHardDelete: args.allowBeliefHardDelete ?? false,
-      reason: args.reason,
-      mutationName: "epistemicNodes.hardDelete"
-    });
-    await ctx.db.insert("epistemicAudit", {
-      entityType: "node",
-      entityId: args.nodeId,
-      changeType: "deleted",
-      projectId: node.projectId,
-      changedBy: "system:hard_delete",
-      changedAt: Date.now(),
-      isAgent: false,
-      previousState: {
-        nodeType: node.nodeType,
-        title: node.title || node.canonicalText?.slice(0, 100),
-        status: node.status
-      },
-      rationale: args.reason
-    });
-    const fromEdges = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", args.nodeId)).collect();
-    const toEdges = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", args.nodeId)).collect();
-    const uniqueEdges = /* @__PURE__ */ new Map();
-    for (const edge of [...fromEdges, ...toEdges]) {
-      uniqueEdges.set(edge.globalId, edge);
-    }
-    for (const edge of uniqueEdges.values()) {
-      await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
-        globalId: edge.globalId
-      });
-      await ctx.db.delete(edge._id);
-    }
-    await ctx.db.delete(args.nodeId);
-    return buildNodeDeletedResult(uniqueEdges.size);
-  }
-});
 var verify = mutation({
   args: {
     nodeId: v.id("epistemicNodes"),
@@ -1409,7 +1360,7 @@ var batchCreate = mutation({
   args: {
     nodes: v.array(
       v.object({
-        ...optionalNodeScopeArgs,
+        ...optionalNodeScopeArgs2,
         globalId: v.string(),
         nodeType: nodeTypeValidator,
         subtype: v.optional(v.string()),
@@ -1507,9 +1458,10 @@ var batchCreate = mutation({
     return { created: results.length, results };
   }
 });
+var optionalNodeScopeArgs3 = optionalScopeArgs;
 var createInternal = internalMutation({
   args: {
-    ...optionalNodeScopeArgs,
+    ...optionalNodeScopeArgs3,
     globalId: v.string(),
     nodeType: nodeTypeValidator,
     subtype: v.optional(v.string()),
@@ -1673,6 +1625,59 @@ var getNodesPendingEdgeSync = internalQuery({
     ).take(limit);
   }
 });
+var hardDelete = internalMutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    reason: v.string(),
+    // Required: document why this is being hard-deleted
+    allowBeliefHardDelete: v.optional(v.boolean())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = await ctx.db.get(args.nodeId);
+    if (!node) {
+      return buildNodeNotFoundResult();
+    }
+    assertBeliefNodeHardDeleteAllowed({
+      node,
+      allowBeliefHardDelete: args.allowBeliefHardDelete ?? false,
+      reason: args.reason,
+      mutationName: "epistemicNodes.hardDelete"
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "node",
+      entityId: args.nodeId,
+      changeType: "deleted",
+      projectId: node.projectId,
+      changedBy: "system:hard_delete",
+      changedAt: Date.now(),
+      isAgent: false,
+      previousState: {
+        nodeType: node.nodeType,
+        title: node.title || node.canonicalText?.slice(0, 100),
+        status: node.status
+      },
+      rationale: args.reason
+    });
+    const fromEdges = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", args.nodeId)).collect();
+    const toEdges = await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", args.nodeId)).collect();
+    const uniqueEdges = /* @__PURE__ */ new Map();
+    for (const edge of [...fromEdges, ...toEdges]) {
+      uniqueEdges.set(edge.globalId, edge);
+    }
+    for (const edge of uniqueEdges.values()) {
+      await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+        globalId: edge.globalId
+      });
+      await ctx.db.delete(edge._id);
+    }
+    await ctx.db.delete(args.nodeId);
+    return buildNodeDeletedResult(uniqueEdges.size);
+  }
+});
+
+// src/epistemicNodes.ts
+var getByTopic = getByProject;
 
 export { archive, backfillTopicId, batchCreate, create, createInternal, epistemicLayerValidator, epistemicNodeTypeValidator, get, getByContentHash, getByGlobalId, getByProject, getByProjectAndType, getByProjectAndTypeLite, getByTopic, getInternal, getNodesPendingEdgeSync, hardDelete, l1NodeTypeValidator, l2NodeTypeValidator, l3NodeTypeValidator, l4NodeTypeValidator, listAll, nodeTypeValidator, ontologicalNodeTypeValidator, organizationalNodeTypeValidator, search, sourceTypeValidator, statusValidator, supersede, update, updateSyncStatus, verificationStatusValidator, verify };
 //# sourceMappingURL=epistemicNodes.js.map