@lucern/graph-primitives 1.0.28 → 1.0.30

package/dist/epistemicBeliefs.internal.js

@@ -1,23 +1,138 @@
-import { v, ConvexError } from 'convex/values';
 import { canAudienceClassAccess, normalizeAudienceKey, classFromAudienceKey } from '@lucern/access-control/audience';
 import { listAudienceRegistryRows } from '@lucern/access-control/audienceRegistry';
 import { assertSchemaEnumValue } from '@lucern/contracts/schema-helpers/enumValidation';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, anyApi, internalQueryGeneric, internalMutationGeneric } from 'convex/server';
-import { generateGlobalId, assertUuidV7Identity, generateUuidV7, assertStorageEdgeVocabulary, assertUuidShapedEdgeEndpoint } from '@lucern/contracts/ids';
-import { assertEdgePolicyAllowed, edgePolicyManifest } from '@lucern/contracts';
-import { isNodeType, getLayerForNodeType } from '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
-import { normalizeTupleContradictionPolicy, confidenceFromSL } from '@lucern/confidence';
-import '@lucern/access-control/access';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { componentsGeneric, internalQueryGeneric, internalMutationGeneric } from 'convex/server';
 import '@lucern/access-control/auth';
+import { throwStructuredMutationError } from '@lucern/access-control/structuredMutationError';
+import { normalizeTupleContradictionPolicy, confidenceFromSL } from '@lucern/confidence';
+import { isNodeType, getLayerForNodeType } from '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
+import { assertEdgePolicyAllowed, edgePolicyManifest } from '@lucern/contracts';
+import { generateGlobalId, assertUuidV7Identity, generateUuidV7, assertStorageEdgeVocabulary, assertUuidShapedEdgeEndpoint } from '@lucern/contracts/ids';
 
 // src/epistemicBeliefs.internal.ts
-var api = anyApi;
+var unsafeApi = unsafeConvexAnyApi(
+  "graph-primitives top-level module bundle lacks a committed Convex _generated/api surface"
+);
+var api = unsafeApi;
 componentsGeneric();
-var internal = anyApi;
+var internal = unsafeApi;
 var internalMutation = internalMutationGeneric;
 var internalQuery = internalQueryGeneric;
 
+// src/beliefLifecycle.ts
+var BELIEF_STATUS_VALUES = [
+  "assumption",
+  "hypothesis",
+  "active",
+  "superseded",
+  "resolved_true",
+  "resolved_false"
+];
+function isBeliefLifecycleStatus(value) {
+  return typeof value === "string" && BELIEF_STATUS_VALUES.includes(value);
+}
+function normalizeLegacyBeliefStatus(value) {
+  if (isBeliefLifecycleStatus(value)) {
+    return value;
+  }
+  if (value === "belief" || value === "established" || value === "emerging") {
+    return "active";
+  }
+  if (value === "fact" || value === "confirmed") {
+    return "resolved_true";
+  }
+  if (value === "disconfirmed" || value === "expired") {
+    return "resolved_false";
+  }
+  if (value === "deprecated") {
+    return "superseded";
+  }
+  return null;
+}
+function normalizeBeliefConfidence(confidence) {
+  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
+    return null;
+  }
+  if (confidence >= 0 && confidence <= 1) {
+    return confidence;
+  }
+  if (confidence > 1 && confidence <= 100) {
+    return confidence / 100;
+  }
+  return null;
+}
+function isResolvedByConfidence(confidence) {
+  const normalized = normalizeBeliefConfidence(confidence);
+  if (normalized === null) {
+    return false;
+  }
+  return normalized <= 0 || normalized >= 1;
+}
+function getPredictionMetaFromMetadata(metadata) {
+  return metadata?.predictionMeta;
+}
+function resolvedPredictionStatus(predictionMeta) {
+  if (!predictionMeta || typeof predictionMeta !== "object") {
+    return null;
+  }
+  const outcome = predictionMeta.outcome;
+  if (outcome === "confirmed") {
+    return "resolved_true";
+  }
+  if (outcome === "disconfirmed" || outcome === "expired") {
+    return "resolved_false";
+  }
+  return null;
+}
+function shouldTreatBeliefAsResolved(opts) {
+  if (isResolvedByConfidence(opts.confidence)) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    return normalized === 0 ? "resolved_false" : "resolved_true";
+  }
+  const directPredictionStatus = resolvedPredictionStatus(opts.predictionMeta);
+  if (directPredictionStatus) {
+    return directPredictionStatus;
+  }
+  const metadataPredictionStatus = resolvedPredictionStatus(
+    getPredictionMetaFromMetadata(opts.metadata)
+  );
+  if (metadataPredictionStatus) {
+    return metadataPredictionStatus;
+  }
+  return null;
+}
+function resolveBeliefLifecycleStatus(opts) {
+  const resolvedStatus = shouldTreatBeliefAsResolved(opts);
+  if (resolvedStatus) {
+    return resolvedStatus;
+  }
+  const direct = opts.beliefStatus;
+  const normalizedDirect = normalizeLegacyBeliefStatus(direct);
+  if (normalizedDirect) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    if (normalized !== null && isPreValidationBeliefStatus(normalizedDirect)) {
+      return "active";
+    }
+    return normalizedDirect;
+  }
+  const metaStatus = opts.metadata?.beliefStatus;
+  const normalizedMetaStatus = normalizeLegacyBeliefStatus(metaStatus);
+  if (normalizedMetaStatus) {
+    const normalized = normalizeBeliefConfidence(opts.confidence);
+    if (normalized !== null && isPreValidationBeliefStatus(normalizedMetaStatus)) {
+      return "active";
+    }
+    return normalizedMetaStatus;
+  }
+  return "assumption";
+}
+function isPreValidationBeliefStatus(status) {
+  return status === "assumption" || status === "hypothesis";
+}
+
 // src/debug.ts
 function isGraphPrimitiveDebugEnabled() {
   const env = globalThis.process?.env;
@@ -30,973 +145,723 @@ function debugGraphPrimitiveFallback(message, context) {
   console.debug(message, context ?? {});
 }
 
-// src/topicScope.ts
+// src/topicProjectOverlay.ts
 var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
-async function resolveTopicNodeScopeOrNull(ctx, ref) {
-  if (!ctx?.db || typeof ctx.db.query !== "function") {
-    return null;
-  }
-  let node = null;
-  try {
-    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", ref)).first();
-    if (byGlobalId && byGlobalId.nodeType === "topic") {
-      node = byGlobalId;
-    }
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] topic-node scope lookup by globalId failed",
-      { error, ref }
-    );
-  }
-  if (!node) {
-    return null;
+function readNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return;
   }
-  const scopeKey = normalizeScopeValue(node.topicId) ?? normalizeScopeValue(node.globalId);
-  if (!scopeKey) {
-    return null;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
   }
-  return {
-    topicId: scopeKey,
-    projectId: asMappedProjectId(node),
-    source: "topic_node"
-  };
+  return value.map((entry) => readNonEmptyString(entry)).filter((entry) => Boolean(entry));
 }
-function asMappedProjectId(topic) {
-  if (!topic) {
+function readMetadata(topic) {
+  return topic.metadata && typeof topic.metadata === "object" ? topic.metadata : {};
+}
+function omitMetadataKey(metadata, key) {
+  const { [key]: _omitted, ...rest } = metadata;
+  return rest;
+}
+function readLegacyProjectId(value) {
+  if (!value) {
     return;
   }
-  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
-  if (directLegacyProjectId) {
-    return directLegacyProjectId;
+  return readNonEmptyString(value[LEGACY_SCOPE_FIELD]);
+}
+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;
   }
-  const metadata = topic.metadata || {};
-  const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
-  return candidate ? candidate : void 0;
+  if (topic.type === "theme") {
+    return "thematic";
+  }
+  return readNonEmptyString(topic.type) || "general";
 }
-function normalizeScopeValue(value) {
-  if (typeof value !== "string") {
-    return;
+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;
   }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : void 0;
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return "unknown error";
 }
-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;
+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
+        }
+      );
     }
-    return String(a.name || "").localeCompare(String(b.name || ""));
-  })[0];
-}
-async function findTopicsByScopeAlias(ctx, scopeId) {
+  }
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
   try {
-    return await ctx.db.query("topics").withIndex(
-      "by_graph_scope_project",
-      (q) => q.eq(LEGACY_SCOPE_FIELD, scopeId)
-    ).collect();
+    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(
-      "[topicScope] Failed to resolve scope alias via index",
+      "[topicProjectOverlay] Failed to resolve topic by ID query",
       {
         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",
+    const topic = await ctx.runQuery(
+      api.topics.getByLegacyScopeId,
       {
-        error,
-        topicId
+        projectId: String(scopeId)
       }
     );
-    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;
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
   } catch (error) {
     debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve topic by legacy scope",
-      {
-        error,
-        legacyScopeId
-      }
+      "[topicProjectOverlay] Failed to resolve topic by legacy scope ID",
+      { error, scopeId }
     );
-    return null;
   }
+  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 };
+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";
+  let createdAt = 0;
+  if (typeof topic.createdAt === "number") {
+    createdAt = topic.createdAt;
+  } else if (typeof topic._creationTime === "number") {
+    createdAt = topic._creationTime;
+  }
+  let updatedAt = createdAt;
+  if (typeof topic.updatedAt === "number") {
+    updatedAt = topic.updatedAt;
+  } else if (typeof metadata.updatedAt === "number") {
+    updatedAt = metadata.updatedAt;
   }
-  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 {
+    ...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",
+    // FR.7 creator-grant: surface the principal-shaped owner field (column-first,
+    // metadata fallback for legacy rows that recorded it in metadata).
+    ownerPrincipalId: readNonEmptyString(topic.ownerPrincipalId) || readNonEmptyString(metadata.ownerPrincipalId),
+    // RR.1 carrier: preserve the nested metadata carrier so the kernel's
+    // `checkProjectAccessDetailed` metadata-PRIMARY read
+    // (`project.metadata?.ownerPrincipalId`) resolves the grant. The `...metadata`
+    // spread above only flattens keys; it does not leave a nested `metadata`.
+    metadata,
+    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;
   }
-  return { tenantId, workspaceId };
+  if (options.projectLikeOnly !== false && !isProjectLikeTopic(topic)) {
+    return null;
+  }
+  return materializeTopicProjectOverlay(topic, options.idMode);
 }
-async function resolveTopicProjectScope(ctx, args) {
-  if (args.topicId) {
-    let topic = null;
+async function listTopicProjectOverlays(ctx, options = {}) {
+  let allTopics = [];
+  if (ctx?.db?.query && typeof ctx.db.query === "function") {
     try {
-      topic = await ctx.db.get(
-        args.topicId
-      );
+      allTopics = await ctx.db.query("topics").collect();
     } catch (error) {
       debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load topic by direct id",
-        {
-          error,
-          topicId: args.topicId
-        }
+        "[topicProjectOverlay] Failed to read topics table; falling back to API",
+        { error }
       );
+      allTopics = [];
     }
-    if (!topic) {
-      topic = await tryResolveHostTopicById(ctx, String(args.topicId));
-    }
-    if (!topic) {
-      topic = pickPrimaryTopic(
-        await findTopicsByScopeAlias(ctx, String(args.topicId))
-      ) ?? null;
+  }
+  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 plan = buildTopicProjectOverlayPatchPlan(topic, value);
+  await applyTopicProjectOverlayPatch(ctx, topic, plan);
+  return materializeTopicProjectOverlay({
+    ...topic,
+    ...plan.patch,
+    metadata: plan.nextMetadata
+  });
+}
+function buildTopicProjectOverlayPatchPlan(topic, value) {
+  const plan = {
+    nextMetadata: { ...readMetadata(topic) },
+    patch: {},
+    topicUpdateArgs: {
+      id: String(topic._id)
     }
-    if (!topic) {
-      const nodeScope = await resolveTopicNodeScopeOrNull(
-        ctx,
-        String(args.topicId)
+  };
+  for (const [key, rawValue] of Object.entries(value)) {
+    applyTopicProjectOverlayPatchEntry(plan, key, rawValue);
+  }
+  plan.patch.updatedAt = Date.now();
+  plan.patch.metadata = plan.nextMetadata;
+  plan.topicUpdateArgs.metadata = plan.nextMetadata;
+  return plan;
+}
+function applyTopicProjectOverlayPatchEntry(plan, key, rawValue) {
+  switch (key) {
+    case "_id":
+    case "projectId":
+    case "topicId":
+    case "legacyProjectId":
+    case "storageProjectId":
+    case "updatedAt":
+    case "createdAt":
+      return;
+    case "name":
+    case "description":
+      plan.patch[key] = rawValue;
+      plan.topicUpdateArgs[key] = rawValue;
+      return;
+    case "tenantId":
+    case "workspaceId":
+    case "ownerId":
+      throw new Error(
+        `patchTopicProjectOverlay cannot mutate ${key} via component-owned topics`
       );
-      if (nodeScope) {
-        return nodeScope;
-      }
-      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"
-    };
+    case "status":
+      applyTopicStatusPatch(plan, rawValue);
+      return;
+    case "visibility":
+      applyTopicVisibilityPatch(plan, rawValue);
+      return;
+    case "type":
+      applyTopicProjectTypePatch(plan, rawValue);
+      return;
+    default:
+      applyTopicMetadataPatch(plan, key, rawValue);
+  }
+}
+function applyTopicStatusPatch(plan, rawValue) {
+  const status = coerceStatus(rawValue);
+  if (status) {
+    plan.patch.status = status;
+    plan.topicUpdateArgs.status = status;
+  }
+}
+function applyTopicVisibilityPatch(plan, rawValue) {
+  const visibility = coerceVisibility(rawValue);
+  if (visibility) {
+    plan.patch.visibility = visibility;
+    plan.topicUpdateArgs.visibility = visibility;
+  }
+}
+function applyTopicProjectTypePatch(plan, rawValue) {
+  const projectType = readNonEmptyString(rawValue);
+  if (projectType) {
+    plan.nextMetadata.projectType = projectType;
+    return;
   }
-  if (args.projectId) {
-    let directTopic = null;
+  plan.nextMetadata = omitMetadataKey(plan.nextMetadata, "projectType");
+}
+function applyTopicMetadataPatch(plan, key, rawValue) {
+  if (rawValue === void 0) {
+    plan.nextMetadata = omitMetadataKey(plan.nextMetadata, key);
+    return;
+  }
+  plan.nextMetadata[key] = rawValue;
+}
+async function applyTopicProjectOverlayPatch(ctx, topic, plan) {
+  if (typeof ctx.runMutation === "function") {
     try {
-      directTopic = await ctx.db.get(
-        args.projectId
-      );
+      await ctx.runMutation(api.topics.update, plan.topicUpdateArgs);
     } 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"
-      };
-    }
-    const nodeScope = await resolveTopicNodeScopeOrNull(
-      ctx,
-      String(args.projectId)
-    );
-    if (nodeScope) {
-      return {
-        ...nodeScope,
-        projectId: nodeScope.projectId ?? String(args.projectId)
-      };
+      if (!canPatchTopicViaLocalDb(ctx, error)) {
+        throw error;
+      }
+      await ctx.db.patch(topic._id, plan.patch);
     }
+  } else if (ctx?.db && typeof ctx.db.patch === "function") {
+    await ctx.db.patch(topic._id, plan.patch);
+  } else {
     throw new Error(
-      `Legacy project scope ${String(args.projectId)} has no mapped topic.`
+      "Cannot patch topic without component adapter (ctx.runMutation unavailable)"
     );
   }
-  throw new Error(
-    "Missing scope: provide topicId (preferred) or legacy projectId alias."
-  );
 }
-var optionalScopeArgs = {
-  projectId: v.optional(v.string()),
-  topicId: v.optional(v.string())
-};
-async function insertEpistemicNode(ctx, doc) {
-  assertUuidV7Identity("epistemicNodes", doc.globalId);
-  return ctx.db.insert("epistemicNodes", doc);
+function canPatchTopicViaLocalDb(ctx, error) {
+  return isMissingLucernChildComponentError(error) && Boolean(ctx?.db) && typeof ctx.db?.patch === "function";
 }
-async function assertExistingNodeEndpoint(ctx, endpointRole, endpoint) {
-  assertUuidShapedEdgeEndpoint(endpointRole, endpoint);
-  const node = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", endpoint)).first();
-  if (!node) {
-    throw new Error(
-      `edge_endpoint_not_canonical: epistemicEdges insert requires ${endpointRole} to be the globalId of an existing epistemicNodes row, received ${endpoint} (no node with that globalId)`
-    );
-  }
+
+// 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");
 }
-async function insertEpistemicEdge(ctx, doc) {
-  assertUuidV7Identity("epistemicEdges", doc.globalId);
-  assertStorageEdgeVocabulary(doc.edgeType);
-  if (!doc.fromNodeId || typeof doc.fromNodeId !== "string") {
-    throw new Error(
-      "edge_endpoint_missing: epistemicEdges insert requires a non-empty fromNodeId"
-    );
+function getErrorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
   }
-  if (!doc.toNodeId || typeof doc.toNodeId !== "string") {
-    throw new Error(
-      "edge_endpoint_missing: epistemicEdges insert requires a non-empty toNodeId"
-    );
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
   }
-  await assertExistingNodeEndpoint(ctx, "fromNodeId", doc.fromNodeId);
-  await assertExistingNodeEndpoint(ctx, "toNodeId", doc.toNodeId);
-  if (doc.fromNodeType && doc.toNodeType && doc.edgeType !== "extracted_from") {
-    assertEdgePolicyAllowed(
-      edgePolicyManifest,
-      doc.edgeType,
-      {
-        kind: "epistemic_node",
-        nodeId: doc.fromNodeId,
-        nodeType: doc.fromNodeType
-      },
+  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",
       {
-        kind: "epistemic_node",
-        nodeId: doc.toNodeId,
-        nodeType: doc.toNodeType
+        projectId,
+        keys: Object.keys(value),
+        error: getErrorMessage2(error)
       }
     );
   }
-  return ctx.db.insert("epistemicEdges", doc);
 }
-
-// src/epistemicBeliefs.topicAnchor.ts
-function cleanString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+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)
+  };
 }
-function topicNodeCandidates(topicRef) {
-  const normalized = topicRef.trim();
-  if (!normalized) {
-    return [];
-  }
-  const candidates = [normalized];
-  if (normalized.startsWith("top_")) {
-    candidates.push(normalized.slice(4));
-  }
-  return [...new Set(candidates)];
-}
-function readTopicNodeRef(args) {
-  return cleanString(args.topicGlobalId) ?? cleanString(args.topicNodeId) ?? cleanString(args.topicId);
-}
-async function resolveRequiredTopicAnchor(ctx, topicRef) {
-  for (const candidate of topicNodeCandidates(topicRef)) {
-    try {
-      const direct = await ctx.db.get(candidate);
-      if (direct?.nodeType === "topic" && cleanString(direct.globalId)) {
-        return direct;
-      }
-    } catch (_) {
-    }
-    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", candidate)).first();
-    if (byGlobalId?.nodeType === "topic" && cleanString(byGlobalId.globalId)) {
-      return byGlobalId;
-    }
-  }
-  throw new Error(
-    "Belief creation requires topicGlobalId or topicNodeId for a topic node in epistemicNodes. Legacy topics-table IDs are not valid belief anchors."
-  );
-}
-function scopeFromTopicAnchor(topicNode) {
+var resolverOverrides = {};
+function resolveGraphPrimitivesAppResolvers(_ctx) {
   return {
-    topicId: topicNode.globalId,
-    projectId: cleanString(topicNode.projectId),
-    tenantId: cleanString(topicNode.tenantId),
-    workspaceId: cleanString(topicNode.workspaceId),
-    source: "topic"
+    ...defaultResolvers(),
+    ...resolverOverrides
   };
 }
-async function createRequiredBeliefTopicEdge(ctx, args) {
-  const topicGlobalId = args.topicNode.globalId;
-  const now = Date.now();
-  const existingEdges = await ctx.db.query("epistemicEdges").withIndex(
-    "by_from_to",
-    (q) => q.eq("fromNodeId", args.beliefGlobalId).eq("toNodeId", topicGlobalId)
-  ).collect();
-  const existing = existingEdges.find((edge) => edge.edgeType === "belongs_to");
-  const edgeGlobalId = cleanString(existing?.globalId) ?? generateUuidV7();
-  if (!existing) {
-    await insertEpistemicEdge(ctx, {
-      globalId: edgeGlobalId,
-      fromNodeId: args.beliefGlobalId,
-      toNodeId: topicGlobalId,
-      sourceGlobalId: args.beliefGlobalId,
-      targetGlobalId: topicGlobalId,
-      edgeType: "belongs_to",
-      weight: 1,
-      confidence: 1,
-      context: "Belief creation topic anchor invariant.",
-      reasoningMethod: "implicit",
-      derivationType: "topic_scope_invariant",
-      metadata: {
-        invariant: "belief.topic_edge_required",
-        edgeUuid: edgeGlobalId,
-        fromUuid: args.beliefGlobalId,
-        toUuid: topicGlobalId
-      },
-      createdBy: args.createdBy,
-      createdAt: now,
-      updatedAt: now,
-      projectId: cleanString(args.topicNode.projectId),
-      topicId: topicGlobalId,
-      tenantId: cleanString(args.topicNode.tenantId),
-      workspaceId: cleanString(args.topicNode.workspaceId),
-      fromNodeType: "belief",
-      toNodeType: "topic",
-      fromLayer: "L3",
-      toLayer: args.topicNode.epistemicLayer ?? "ontological"
-    });
+var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
+async function resolveTopicNodeScopeOrNull(ctx, ref) {
+  if (!ctx?.db || typeof ctx.db.query !== "function") {
+    return null;
   }
-  await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
-    globalId: edgeGlobalId,
-    fromGlobalId: args.beliefGlobalId,
-    toGlobalId: topicGlobalId,
-    edgeType: "belongs_to",
-    weight: 1,
-    confidence: 1,
-    context: "Belief creation topic anchor invariant.",
-    projectId: cleanString(args.topicNode.projectId),
-    topicId: topicGlobalId,
-    createdBy: args.createdBy,
-    fromNodeType: "belief",
-    toNodeType: "topic",
-    fromLayer: "L3",
-    toLayer: args.topicNode.epistemicLayer ?? "ontological",
-    metadata: {
-      invariant: "belief.topic_edge_required",
-      edgeUuid: edgeGlobalId,
-      fromUuid: args.beliefGlobalId,
-      toUuid: topicGlobalId
+  let node = null;
+  try {
+    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", ref)).first();
+    if (byGlobalId && byGlobalId.nodeType === "topic") {
+      node = byGlobalId;
     }
-  });
-}
-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;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] topic-node scope lookup by globalId failed",
+      { error, ref }
+    );
   }
-  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 null;
   }
-  return scopeWorkspaceId === nodeWorkspaceId;
-}
-function resolveRuntimePackMutationContext(args) {
-  if (!args.runtimeToolName && !args.runtimePackKey && !args.runtimePackInstallScope) {
-    return;
+  const scopeKey = normalizeScopeValue(node.topicId) ?? normalizeScopeValue(node.globalId);
+  if (!scopeKey) {
+    return null;
   }
   return {
-    toolName: args.runtimeToolName,
-    packKey: args.runtimePackKey,
-    packInstallScope: args.runtimePackInstallScope
+    topicId: scopeKey,
+    projectId: asMappedProjectId(node),
+    source: "topic_node"
   };
 }
-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") {
+function asMappedProjectId(topic) {
+  if (!topic) {
     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/beliefLifecycle.ts
-var BELIEF_STATUS_VALUES = [
-  "assumption",
-  "hypothesis",
-  "active",
-  "superseded",
-  "resolved_true",
-  "resolved_false"
-];
-function isBeliefLifecycleStatus(value) {
-  return typeof value === "string" && BELIEF_STATUS_VALUES.includes(value);
-}
-function normalizeLegacyBeliefStatus(value) {
-  if (isBeliefLifecycleStatus(value)) {
-    return value;
-  }
-  if (value === "belief" || value === "established" || value === "emerging") {
-    return "active";
-  }
-  if (value === "fact" || value === "confirmed") {
-    return "resolved_true";
-  }
-  if (value === "disconfirmed" || value === "expired") {
-    return "resolved_false";
-  }
-  if (value === "deprecated") {
-    return "superseded";
-  }
-  return null;
-}
-function normalizeBeliefConfidence(confidence) {
-  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
-    return null;
-  }
-  if (confidence >= 0 && confidence <= 1) {
-    return confidence;
-  }
-  if (confidence > 1 && confidence <= 100) {
-    return confidence / 100;
-  }
-  return null;
-}
-function isResolvedByConfidence(confidence) {
-  const normalized = normalizeBeliefConfidence(confidence);
-  if (normalized === null) {
-    return false;
-  }
-  return normalized <= 0 || normalized >= 1;
-}
-function getPredictionMetaFromMetadata(metadata) {
-  return metadata?.predictionMeta;
-}
-function resolvedPredictionStatus(predictionMeta) {
-  if (!predictionMeta || typeof predictionMeta !== "object") {
-    return null;
-  }
-  const outcome = predictionMeta.outcome;
-  if (outcome === "confirmed") {
-    return "resolved_true";
-  }
-  if (outcome === "disconfirmed" || outcome === "expired") {
-    return "resolved_false";
-  }
-  return null;
-}
-function shouldTreatBeliefAsResolved(opts) {
-  if (isResolvedByConfidence(opts.confidence)) {
-    const normalized = normalizeBeliefConfidence(opts.confidence);
-    return normalized === 0 ? "resolved_false" : "resolved_true";
-  }
-  const directPredictionStatus = resolvedPredictionStatus(opts.predictionMeta);
-  if (directPredictionStatus) {
-    return directPredictionStatus;
-  }
-  const metadataPredictionStatus = resolvedPredictionStatus(
-    getPredictionMetaFromMetadata(opts.metadata)
+  const directLegacyProjectId = normalizeScopeValue(
+    topic[LEGACY_SCOPE_FIELD2]
   );
-  if (metadataPredictionStatus) {
-    return metadataPredictionStatus;
-  }
-  return null;
-}
-function resolveBeliefLifecycleStatus(opts) {
-  const resolvedStatus = shouldTreatBeliefAsResolved(opts);
-  if (resolvedStatus) {
-    return resolvedStatus;
-  }
-  const direct = opts.beliefStatus;
-  const normalizedDirect = normalizeLegacyBeliefStatus(direct);
-  if (normalizedDirect) {
-    const normalized = normalizeBeliefConfidence(opts.confidence);
-    if (normalized !== null && isPreValidationBeliefStatus(normalizedDirect)) {
-      return "active";
-    }
-    return normalizedDirect;
-  }
-  const metaStatus = opts.metadata?.beliefStatus;
-  const normalizedMetaStatus = normalizeLegacyBeliefStatus(metaStatus);
-  if (normalizedMetaStatus) {
-    const normalized = normalizeBeliefConfidence(opts.confidence);
-    if (normalized !== null && isPreValidationBeliefStatus(normalizedMetaStatus)) {
-      return "active";
-    }
-    return normalizedMetaStatus;
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
   }
-  return "assumption";
-}
-function isPreValidationBeliefStatus(status) {
-  return status === "assumption" || status === "hypothesis";
+  const metadata = topic.metadata || {};
+  const candidate = metadata[LEGACY_SCOPE_FIELD2] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
+  return typeof candidate === "string" ? normalizeScopeValue(candidate) : void 0;
 }
-
-// src/topicProjectOverlay.ts
-var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
-function readNonEmptyString(value) {
+function normalizeScopeValue(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
-        }
-      );
+function pickPrimaryTopic(candidates) {
+  return [...candidates].sort((a, b) => {
+    const depthA = a.depth ?? 9999;
+    const depthB = b.depth ?? 9999;
+    if (depthA !== depthB) {
+      return depthA - depthB;
     }
-  }
-  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;
+    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) {
+  const query = ctx.db.query("topics");
+  try {
+    return await query.withIndex(
+      "by_graph_scope_project",
+      (q) => q.eq(LEGACY_SCOPE_FIELD2, scopeId)
+    ).collect();
   } catch (error) {
     debugGraphPrimitiveFallback(
-      "[topicProjectOverlay] Failed to resolve topic by ID query",
+      "[topicScope] Failed to resolve scope alias via index",
       {
         error,
         scopeId
       }
     );
+    const topics = await query.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 {
-    const topic = await ctx.runQuery(api.topics.getByLegacyScopeId, {
-      projectId: String(scopeId)
-    });
-    if (topic?.name !== void 0 && topic?.type !== void 0) {
-      return topic;
-    }
+    return await ctx.runQuery(api.topics.get, {
+      id: topicId
+    }) ?? null;
   } catch (error) {
     debugGraphPrimitiveFallback(
-      "[topicProjectOverlay] Failed to resolve topic by legacy scope ID",
-      { error, scopeId }
+      "[topicScope] Failed to resolve topic by host query",
+      {
+        error,
+        topicId
+      }
     );
+    return null;
   }
-  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",
-    // FR.7 creator-grant: surface the principal-shaped owner field (column-first,
-    // metadata fallback for legacy rows that recorded it in metadata).
-    ownerPrincipalId: readNonEmptyString(topic.ownerPrincipalId) || readNonEmptyString(metadata.ownerPrincipalId),
-    // RR.1 carrier: preserve the nested metadata carrier so the kernel's
-    // `checkProjectAccessDetailed` metadata-PRIMARY read
-    // (`project.metadata?.ownerPrincipalId`) resolves the grant. The `...metadata`
-    // spread above only flattens keys; it does not leave a nested `metadata`.
-    metadata,
-    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) {
+async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
+  if (typeof ctx.runQuery !== "function") {
     return null;
   }
-  if (options.projectLikeOnly !== false && !isProjectLikeTopic(topic)) {
+  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;
   }
-  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 = [];
-    }
+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 };
   }
-  if (allTopics.length === 0 && typeof ctx.runQuery === "function") {
-    allTopics = (await ctx.runQuery(api.topics.list, {}) ?? []) || [];
+  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 allTopics.filter(
-    (topic) => options.projectLikeOnly === false || isProjectLikeTopic(topic)
-  ).map((topic) => materializeTopicProjectOverlay(topic, options.idMode));
+  return { tenantId, workspaceId };
 }
-async function patchTopicProjectOverlay(ctx, scopeId, value) {
-  const topic = await resolveTopicDoc(ctx, scopeId);
-  if (!topic) {
-    return null;
+async function resolveTopicProjectScope(ctx, args) {
+  if (args.topicId) {
+    return await resolveScopeFromTopicId(ctx, args.topicId);
   }
-  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;
-        }
-    }
+  if (args.projectId) {
+    return await resolveScopeFromLegacyProjectId(ctx, args.projectId);
   }
-  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)"
-    );
+  throw new Error(
+    "Missing scope: provide topicId (preferred) or legacy projectId alias."
+  );
+}
+async function resolveScopeFromTopicId(ctx, topicId) {
+  const topic = await resolveTopicDocFromTopicId(ctx, topicId);
+  if (topic) {
+    return await buildTopicScope(ctx, topic, "topic");
   }
-  return materializeTopicProjectOverlay({
-    ...topic,
-    ...patch,
-    metadata: nextMetadata
-  });
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, String(topicId));
+  if (nodeScope) {
+    return nodeScope;
+  }
+  throw new Error(`Topic not found: ${String(topicId)}`);
 }
-
-// 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");
+async function resolveTopicDocFromTopicId(ctx, topicId) {
+  const direct = await tryReadTopicDoc(ctx, topicId, {
+    failureLog: "[topicScope] Failed to load topic by direct id",
+    idLogKey: "topicId"
+  });
+  if (direct) {
+    return direct;
+  }
+  const hostTopic = await tryResolveHostTopicById(ctx, String(topicId));
+  if (hostTopic) {
+    return hostTopic;
+  }
+  return pickPrimaryTopic(await findTopicsByScopeAlias(ctx, String(topicId))) ?? null;
 }
-function getErrorMessage2(error) {
-  if (error instanceof Error) {
-    return error.message;
+async function resolveScopeFromLegacyProjectId(ctx, legacyProjectId) {
+  const directTopic = await resolveDirectLegacyProjectTopic(
+    ctx,
+    legacyProjectId
+  );
+  if (directTopic) {
+    return await buildTopicScope(ctx, directTopic, "topic_inferred", {
+      fallbackProjectId: legacyProjectId
+    });
   }
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message;
+  const primary = pickPrimaryTopic(
+    await findTopicsByScopeAlias(ctx, legacyProjectId)
+  );
+  if (primary) {
+    return await buildTopicScope(ctx, primary, "project_mapped_topic", {
+      fallbackProjectId: legacyProjectId
+    });
   }
-  return "unknown error";
+  const nodeScope = await resolveTopicNodeScopeOrNull(ctx, legacyProjectId);
+  if (nodeScope) {
+    return {
+      ...nodeScope,
+      projectId: nodeScope.projectId ?? legacyProjectId
+    };
+  }
+  throw new Error(
+    `Legacy project scope ${legacyProjectId} has no mapped topic.`
+  );
 }
-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 resolveDirectLegacyProjectTopic(ctx, legacyProjectId) {
+  const directTopic = await tryReadTopicDoc(ctx, legacyProjectId, {
+    failureLog: "[topicScope] Failed to load direct project topic",
+    idLogKey: "projectId"
+  });
+  return directTopic ?? tryResolveHostTopicByLegacyScope(ctx, legacyProjectId);
 }
-async function patchProjectWithTolerance(ctx, projectId, value) {
+async function tryReadTopicDoc(ctx, id, log) {
   try {
-    await patchTopicProjectOverlay(ctx, projectId, value);
+    return await ctx.db.get(id);
   } 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)
-      }
-    );
+    debugGraphPrimitiveFallback(log.failureLog, {
+      error,
+      [log.idLogKey]: id
+    });
+    return null;
   }
 }
-function defaultResolvers() {
+async function buildTopicScope(ctx, topic, source, options = {}) {
+  const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
+  const mapped = asMappedProjectId(topic);
   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)
+    topicId: topic._id,
+    ...mapped || options.fallbackProjectId ? { projectId: mapped ?? options.fallbackProjectId } : {},
+    tenantId: inherited.tenantId,
+    workspaceId: inherited.workspaceId,
+    source
   };
 }
-var resolverOverrides = {};
-function resolveGraphPrimitivesAppResolvers(_ctx) {
+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;
+}
+function resolveRuntimePackMutationContext(args) {
+  if (!(args.runtimeToolName || args.runtimePackKey || args.runtimePackInstallScope)) {
+    return;
+  }
   return {
-    ...defaultResolvers(),
-    ...resolverOverrides
+    toolName: args.runtimeToolName,
+    packKey: args.runtimePackKey,
+    packInstallScope: args.runtimePackInstallScope
   };
 }
-
-// src/epistemicBeliefs.helpers.ts
+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
+    }
+  });
+}
 v.id("epistemicNodes");
 var DEFAULT_PROJECT_BELIEF_LIMIT = 250;
 var MAX_PROJECT_BELIEF_LIMIT = 1e3;
@@ -1004,25 +869,119 @@ var optionalBeliefScopeArgs = optionalScopeArgs;
 ({
   tupleContradiction: normalizeTupleContradictionPolicy()
 });
-function throwStructuredMutationError(args) {
-  const data = {
-    structuredMutationError: true,
-    message: args.message,
-    status: args.status,
-    code: args.code,
-    invariantCode: args.invariantCode,
-    suggestion: args.suggestion,
-    details: args.details
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readStringArray2(value) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  const strings = value.filter(
+    (item) => typeof item === "string" && item.length > 0
+  );
+  return strings.length === value.length ? strings : void 0;
+}
+function readRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+function readBeliefNodeView(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const id = readOptionalString(value._id);
+  const nodeType = readOptionalString(value.nodeType);
+  if (!(id && nodeType === "belief")) {
+    return null;
+  }
+  const node = {
+    _id: id,
+    nodeType
   };
-  const error = new ConvexError(
-    data
-  );
-  error.status = args.status;
-  error.code = args.code;
-  error.invariantCode = args.invariantCode;
-  error.suggestion = args.suggestion;
-  error.details = args.details;
-  throw error;
+  const creationTime = readFiniteNumber(value._creationTime);
+  if (creationTime !== void 0) {
+    node._creationTime = creationTime;
+  }
+  const metadata = readRecord(value.metadata);
+  if (metadata !== void 0) {
+    node.metadata = metadata;
+  }
+  const opinionA = readFiniteNumber(value.opinion_a);
+  if (opinionA !== void 0) {
+    node.opinion_a = opinionA;
+  }
+  const opinionB = readFiniteNumber(value.opinion_b);
+  if (opinionB !== void 0) {
+    node.opinion_b = opinionB;
+  }
+  const opinionD = readFiniteNumber(value.opinion_d);
+  if (opinionD !== void 0) {
+    node.opinion_d = opinionD;
+  }
+  const opinionU = readFiniteNumber(value.opinion_u);
+  if (opinionU !== void 0) {
+    node.opinion_u = opinionU;
+  }
+  const tupleContradicted = typeof value.tupleContradicted === "boolean" ? value.tupleContradicted : void 0;
+  if (tupleContradicted !== void 0) {
+    node.tupleContradicted = tupleContradicted;
+  }
+  const stringFields = {
+    anonymizationClass: value.anonymizationClass,
+    audienceLabel: value.audienceLabel,
+    canonicalText: value.canonicalText,
+    createdBy: value.createdBy,
+    epistemicLayer: value.epistemicLayer,
+    exportClass: value.exportClass,
+    globalId: value.globalId,
+    projectId: value.projectId,
+    publicationStatus: value.publicationStatus,
+    sensitivityTier: value.sensitivityTier,
+    status: value.status,
+    tenantId: value.tenantId,
+    topicId: value.topicId,
+    userId: value.userId,
+    workspaceId: value.workspaceId
+  };
+  for (const [field, fieldValue] of Object.entries(stringFields)) {
+    const normalized = readOptionalString(fieldValue);
+    if (normalized !== void 0) {
+      node[field] = normalized;
+    }
+  }
+  const createdAt = readFiniteNumber(value.createdAt);
+  if (createdAt !== void 0) {
+    node.createdAt = createdAt;
+  }
+  const updatedAt = readFiniteNumber(value.updatedAt);
+  if (updatedAt !== void 0) {
+    node.updatedAt = updatedAt;
+  }
+  if (value.beliefStatus !== void 0) {
+    node.beliefStatus = value.beliefStatus;
+  }
+  if (value.confidence !== void 0) {
+    node.confidence = value.confidence;
+  }
+  if (value.predictionMeta !== void 0) {
+    node.predictionMeta = value.predictionMeta;
+  }
+  const policyTags = readStringArray2(value.policyTags);
+  if (policyTags !== void 0) {
+    node.policyTags = policyTags;
+  }
+  return node;
+}
+function readBeliefNodeViews(values) {
+  return values.flatMap((value) => {
+    const node = readBeliefNodeView(value);
+    return node ? [node] : [];
+  });
 }
 function assertBaseRateInRange(baseRate, field = "baseRate") {
   if (baseRate < 0 || baseRate > 1) {
@@ -1118,7 +1077,7 @@ function normalizePillar(pillar) {
 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) {
+  if (!(projectId || topicId)) {
     return;
   }
   if (projectId) {
@@ -1135,16 +1094,22 @@ async function markBeliefGraphDirty(ctx, scope) {
       { topicId }
     );
   }
+  const activityScopeId = topicId ?? projectId;
+  if (!activityScopeId) {
+    throw new Error(
+      "Expected belief graph dirty scope to include a topic or project id."
+    );
+  }
   await resolveGraphPrimitivesAppResolvers().patchProject(
     ctx,
-    topicId ?? projectId,
+    activityScopeId,
     {
       lastActivityAt: Date.now()
     }
   );
 }
 async function resolveBeliefScopeOrNull(ctx, args) {
-  if (!args.projectId && !args.topicId) {
+  if (!(args.projectId || args.topicId)) {
     return null;
   }
   try {
@@ -1169,14 +1134,17 @@ async function getBeliefNodesForScope(ctx, scope, args) {
     "by_topic_type",
     (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
   );
-  const nodes = typeof args?.scanLimit === "number" ? await baseQuery.order("desc").take(args.scanLimit) : await baseQuery.collect();
+  const rows = typeof args?.scanLimit === "number" ? await baseQuery.order("desc").take(args.scanLimit) : await baseQuery.collect();
+  const nodes = readBeliefNodeViews(rows);
   const scopedNodes = nodes.filter(
     (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
   );
   if (!args?.status) {
     return scopedNodes;
   }
-  return scopedNodes.filter((node) => node.status === args.status);
+  return scopedNodes.filter(
+    (node) => node.status === args.status
+  );
 }
 function createBeliefAudienceResolver(registryRows) {
   const audienceClassByKey = new Map(
@@ -1196,9 +1164,7 @@ function createBeliefAudienceResolver(registryRows) {
 function flattenBeliefNode(node) {
   const meta = node.metadata || {};
   const worktreeId = resolveBeliefWorktreeId(meta);
-  const tupleContradicted = readTupleContradictedFlag(
-    node.tupleContradicted
-  ) ?? readTupleContradictedFlag(meta.tupleContradicted) ?? false;
+  const tupleContradicted = readTupleContradictedFlag(node.tupleContradicted) ?? readTupleContradictedFlag(meta.tupleContradicted) ?? false;
   return {
     _id: node._id,
     _epistemicNodeId: node._id,
@@ -1243,8 +1209,172 @@ function resolveBeliefStatus(node, metadata) {
     metadata
   });
 }
+function insertEpistemicNode(ctx, doc) {
+  assertUuidV7Identity("epistemicNodes", doc.globalId);
+  return ctx.db.insert("epistemicNodes", doc);
+}
+async function assertExistingNodeEndpoint(ctx, endpointRole, endpoint) {
+  assertUuidShapedEdgeEndpoint(endpointRole, endpoint);
+  const node = await ctx.db.query("epistemicNodes").withIndex(
+    "by_globalId",
+    (q) => q.eq("globalId", endpoint)
+  ).first();
+  if (!node) {
+    throw new Error(
+      `edge_endpoint_not_canonical: epistemicEdges insert requires ${endpointRole} to be the globalId of an existing epistemicNodes row, received ${endpoint} (no node with that globalId)`
+    );
+  }
+}
+async function insertEpistemicEdge(ctx, doc) {
+  assertUuidV7Identity("epistemicEdges", doc.globalId);
+  assertStorageEdgeVocabulary(doc.edgeType);
+  if (!doc.fromNodeId || typeof doc.fromNodeId !== "string") {
+    throw new Error(
+      "edge_endpoint_missing: epistemicEdges insert requires a non-empty fromNodeId"
+    );
+  }
+  if (!doc.toNodeId || typeof doc.toNodeId !== "string") {
+    throw new Error(
+      "edge_endpoint_missing: epistemicEdges insert requires a non-empty toNodeId"
+    );
+  }
+  await assertExistingNodeEndpoint(ctx, "fromNodeId", doc.fromNodeId);
+  await assertExistingNodeEndpoint(ctx, "toNodeId", doc.toNodeId);
+  if (doc.fromNodeType && doc.toNodeType && doc.edgeType !== "extracted_from") {
+    assertEdgePolicyAllowed(
+      edgePolicyManifest,
+      doc.edgeType,
+      {
+        kind: "epistemic_node",
+        nodeId: doc.fromNodeId,
+        nodeType: doc.fromNodeType
+      },
+      {
+        kind: "epistemic_node",
+        nodeId: doc.toNodeId,
+        nodeType: doc.toNodeType
+      }
+    );
+  }
+  return ctx.db.insert("epistemicEdges", doc);
+}
+
+// src/epistemicBeliefs.topicAnchor.ts
+function cleanString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function topicNodeCandidates(topicRef) {
+  const normalized = topicRef.trim();
+  if (!normalized) {
+    return [];
+  }
+  const candidates = [normalized];
+  if (normalized.startsWith("top_")) {
+    candidates.push(normalized.slice(4));
+  }
+  return [...new Set(candidates)];
+}
+function readTopicNodeRef(args) {
+  return cleanString(args.topicGlobalId) ?? cleanString(args.topicNodeId) ?? cleanString(args.topicId);
+}
+async function resolveRequiredTopicAnchor(ctx, topicRef) {
+  for (const candidate of topicNodeCandidates(topicRef)) {
+    try {
+      const direct = await ctx.db.get(candidate);
+      if (direct?.nodeType === "topic" && cleanString(direct.globalId)) {
+        return direct;
+      }
+    } catch {
+    }
+    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", candidate)).first();
+    if (byGlobalId?.nodeType === "topic" && cleanString(byGlobalId.globalId)) {
+      return byGlobalId;
+    }
+  }
+  throw new Error(
+    "Belief creation requires topicGlobalId or topicNodeId for a topic node in epistemicNodes. Legacy topics-table IDs are not valid belief anchors."
+  );
+}
+function scopeFromTopicAnchor(topicNode) {
+  return {
+    topicId: topicNode.globalId,
+    projectId: cleanString(topicNode.projectId),
+    tenantId: cleanString(topicNode.tenantId),
+    workspaceId: cleanString(topicNode.workspaceId),
+    source: "topic"
+  };
+}
+async function createRequiredBeliefTopicEdge(ctx, args) {
+  const topicGlobalId = args.topicNode.globalId;
+  const now = Date.now();
+  const existingEdges = await ctx.db.query("epistemicEdges").withIndex(
+    "by_from_to",
+    (q) => q.eq("fromNodeId", args.beliefGlobalId).eq("toNodeId", topicGlobalId)
+  ).collect();
+  const existing = existingEdges.find((edge) => edge.edgeType === "belongs_to");
+  const edgeGlobalId = cleanString(existing?.globalId) ?? generateUuidV7();
+  if (!existing) {
+    await insertEpistemicEdge(ctx, {
+      globalId: edgeGlobalId,
+      fromNodeId: args.beliefGlobalId,
+      toNodeId: topicGlobalId,
+      sourceGlobalId: args.beliefGlobalId,
+      targetGlobalId: topicGlobalId,
+      edgeType: "belongs_to",
+      weight: 1,
+      confidence: 1,
+      context: "Belief creation topic anchor invariant.",
+      reasoningMethod: "implicit",
+      derivationType: "topic_scope_invariant",
+      metadata: {
+        invariant: "belief.topic_edge_required",
+        edgeUuid: edgeGlobalId,
+        fromUuid: args.beliefGlobalId,
+        toUuid: topicGlobalId
+      },
+      createdBy: args.createdBy,
+      createdAt: now,
+      updatedAt: now,
+      projectId: cleanString(args.topicNode.projectId),
+      topicId: topicGlobalId,
+      tenantId: cleanString(args.topicNode.tenantId),
+      workspaceId: cleanString(args.topicNode.workspaceId),
+      fromNodeType: "belief",
+      toNodeType: "topic",
+      fromLayer: "L3",
+      toLayer: args.topicNode.epistemicLayer ?? "ontological"
+    });
+  }
+  await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+    globalId: edgeGlobalId,
+    fromGlobalId: args.beliefGlobalId,
+    toGlobalId: topicGlobalId,
+    edgeType: "belongs_to",
+    weight: 1,
+    confidence: 1,
+    context: "Belief creation topic anchor invariant.",
+    projectId: cleanString(args.topicNode.projectId),
+    topicId: topicGlobalId,
+    createdBy: args.createdBy,
+    fromNodeType: "belief",
+    toNodeType: "topic",
+    fromLayer: "L3",
+    toLayer: args.topicNode.epistemicLayer ?? "ontological",
+    metadata: {
+      invariant: "belief.topic_edge_required",
+      edgeUuid: edgeGlobalId,
+      fromUuid: args.beliefGlobalId,
+      toUuid: topicGlobalId
+    }
+  });
+}
 
 // src/epistemicBeliefs.internal.ts
+var BELIEF_CATEGORIZATION_ACTION = "beliefCategorization:autoCategorizeBelief";
+var EMBEDDING_GENERATION_ACTION = "embeddingActions:generateEpistemicNodeEmbedding";
+function readOptionalString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
 var internalGetByProject = internalQuery({
   args: {
     ...optionalBeliefScopeArgs,
@@ -1279,7 +1409,7 @@ var internalGetByProject = internalQuery({
     let filtered = nodes.filter(
       (node) => canAudienceClassAccess(
         viewerClass,
-        resolveAudienceClass(node.audienceLabel, "internal")
+        resolveAudienceClass(readOptionalString2(node.audienceLabel), "internal")
       )
     );
     if (args.status) {
@@ -1318,15 +1448,18 @@ var internalGetByTopic = internalQuery({
     });
     const resolveAudienceClass = createBeliefAudienceResolver(registryRows);
     const viewerClass = resolveAudienceClass(audienceMode, "public");
-    const query3 = ctx.db.query("epistemicNodes").withIndex(
+    const query = 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 nodes = (await query.order("desc").take(scanLimit)).flatMap((row) => {
+      const node = readBeliefNodeView(row);
+      return node ? [node] : [];
+    });
     let filtered = nodes.filter(
       (node) => canAudienceClassAccess(
         viewerClass,
-        resolveAudienceClass(node.audienceLabel, "internal")
+        resolveAudienceClass(readOptionalString2(node.audienceLabel), "internal")
       )
     );
     if (args.status) {
@@ -1360,11 +1493,16 @@ var internalGetById = internalQuery({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.beliefId);
-    if (!node || node.nodeType !== "belief") {
+    const nodeId = ctx.db.normalizeId?.("epistemicNodes", args.beliefId);
+    if (!nodeId) {
+      return null;
+    }
+    const node = await ctx.db.get(nodeId);
+    const beliefNode = readBeliefNodeView(node);
+    if (!beliefNode) {
       return null;
     }
-    return flattenBeliefNode(node);
+    return flattenBeliefNode(beliefNode);
   }
 });
 var internalCreate = internalMutation({
@@ -1407,171 +1545,235 @@ var internalCreate = internalMutation({
     )
   },
   returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const now = Date.now();
-    const baseRate = assertBaseRateInRange(args.baseRate ?? 0.5);
-    const topicRef = readTopicNodeRef(args);
-    if (!topicRef) {
-      throw new Error(
-        "Belief creation requires topicGlobalId or topicNodeId for a topic node in epistemicNodes."
-      );
-    }
-    const topicNode = await resolveRequiredTopicAnchor(ctx, topicRef);
-    const scope = scopeFromTopicAnchor(topicNode);
-    assertWorkspaceScopedEpistemicNodeScope({
-      scope,
-      nodeType: "belief",
-      mutationName: "epistemicBeliefs.internalCreate"
-    });
-    assertTenantPackWorkspaceMutationAllowed({
-      runtime: resolveRuntimePackMutationContext(args),
-      target: {
-        tenantId: scope.tenantId,
-        workspaceId: scope.workspaceId,
-        nodeType: "belief",
-        epistemicLayer: "L3"
-      },
-      mutationName: "epistemicBeliefs.internalCreate"
-    });
-    const normalizedBeliefType = await assertSchemaEnumValue(ctx, {
-      category: "belief_type",
-      value: args.beliefType,
-      tenantId: scope.tenantId,
-      context: "epistemicBeliefs.internalCreate"
-    });
-    const globalId = generateGlobalId();
-    const contentHash = generateContentHash(args.formulation);
-    const requestedConfidence = args.confidence;
-    const seedOpinion = {
-      opinion_b: 0,
-      opinion_d: 0,
-      opinion_u: 1,
-      opinion_a: baseRate
-    };
-    const nodeId = await insertEpistemicNode(ctx, {
+  handler: async (ctx, args) => await createInternalBelief(ctx, args)
+});
+async function createInternalBelief(ctx, args) {
+  const now = Date.now();
+  const baseRate = assertBaseRateInRange(args.baseRate ?? 0.5);
+  const topicNode = await resolveInternalCreateTopicAnchor(ctx, args);
+  const anchoredScope = scopeFromTopicAnchor(topicNode);
+  const scope = {
+    ...anchoredScope,
+    topicId: anchoredScope.topicId
+  };
+  assertInternalCreateScope(args, scope);
+  const normalizedBeliefType = await assertSchemaEnumValue(ctx, {
+    category: "belief_type",
+    value: args.beliefType,
+    tenantId: scope.tenantId,
+    context: "epistemicBeliefs.internalCreate"
+  });
+  const seedOpinion = buildSeedOpinion(baseRate);
+  const globalId = generateGlobalId();
+  const nodeId = await insertEpistemicNode(
+    ctx,
+    buildInternalBeliefNode({
+      args,
       globalId,
-      topicId: scope.topicId,
-      projectId: scope.projectId,
+      normalizedBeliefType,
+      now,
+      scope,
+      seedOpinion
+    })
+  );
+  await insertInternalBeliefConfidence(ctx, {
+    args,
+    baseRate,
+    nodeId,
+    now,
+    seedOpinion
+  });
+  await createRequiredBeliefTopicEdge(ctx, {
+    beliefGlobalId: globalId,
+    topicNode,
+    createdBy: args.userId
+  });
+  await scheduleInternalBeliefSideEffects(ctx, {
+    args,
+    baseRate,
+    nodeId,
+    now,
+    scope,
+    seedOpinion
+  });
+  return { nodeId };
+}
+async function resolveInternalCreateTopicAnchor(ctx, args) {
+  const topicRef = readTopicNodeRef(args);
+  if (!topicRef) {
+    throw new Error(
+      "Belief creation requires topicGlobalId or topicNodeId for a topic node in epistemicNodes."
+    );
+  }
+  return await resolveRequiredTopicAnchor(ctx, topicRef);
+}
+function assertInternalCreateScope(args, scope) {
+  assertWorkspaceScopedEpistemicNodeScope({
+    scope,
+    nodeType: "belief",
+    mutationName: "epistemicBeliefs.internalCreate"
+  });
+  assertTenantPackWorkspaceMutationAllowed({
+    runtime: resolveRuntimePackMutationContext(args),
+    target: {
       tenantId: scope.tenantId,
       workspaceId: scope.workspaceId,
       nodeType: "belief",
-      canonicalText: args.formulation,
-      contentHash,
-      status: "active",
-      epistemicLayer: "L3",
-      // L3: Traversal Anchors
-      sourceType: args.userId.startsWith("agent:") ? "ai_generated" : "human",
-      ...normalizedBeliefType ? { beliefType: normalizedBeliefType } : {},
-      createdAt: now,
-      updatedAt: now,
-      createdBy: args.userId,
-      ...seedOpinion,
-      tupleContradicted: false,
-      metadata: {
-        ...requestedConfidence ? { confidence: requestedConfidence } : {},
-        tupleContradicted: false,
-        rationale: args.rationale || "",
-        topic: args.topic || args.pillar || "",
-        pillar: args.pillar || args.topic || "",
-        category: args.category || "",
-        subcategory: args.subcategory || "",
-        categoryIcon: args.categoryIcon || "",
-        sprintId: args.sprintId,
-        sourceBeliefIds: args.sourceBeliefIds || [],
-        criticality: args.criticality || "unanalyzed",
-        ...normalizedBeliefType ? { beliefType: normalizedBeliefType } : {},
-        supportingEvidenceIds: [],
-        contradictingEvidenceIds: [],
-        testingQuestionIds: [],
-        linkedInsightIds: [],
-        // Merge caller-provided metadata (e.g. codeAnchors for coding intelligence)
-        ...args.extraMetadata && typeof args.extraMetadata === "object" ? args.extraMetadata : {}
-      }
-    });
-    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: args.userId,
-        assessedAt: now,
-        slOperator: "prior_seed"
-      })
-    );
-    await createRequiredBeliefTopicEdge(ctx, {
-      beliefGlobalId: globalId,
-      topicNode,
-      createdBy: args.userId
-    });
-    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
-      nodeId,
-      operation: "upsert"
-    });
-    await ctx.db.insert("epistemicAudit", {
-      entityType: "belief",
-      entityId: nodeId,
-      changeType: "created",
-      changedAt: now,
-      changedBy: args.userId,
-      isAgent: false,
-      newState: {
-        formulation: args.formulation,
-        baseRate,
-        confidence: requestedConfidence,
-        opinion: {
-          b: seedOpinion.opinion_b,
-          d: seedOpinion.opinion_d,
-          u: seedOpinion.opinion_u,
-          a: seedOpinion.opinion_a
-        },
-        tupleContradicted: false,
-        source: "internal"
+      epistemicLayer: "L3"
+    },
+    mutationName: "epistemicBeliefs.internalCreate"
+  });
+}
+function buildSeedOpinion(baseRate) {
+  return {
+    opinion_b: 0,
+    opinion_d: 0,
+    opinion_u: 1,
+    opinion_a: baseRate
+  };
+}
+function buildInternalBeliefNode(args) {
+  return {
+    globalId: args.globalId,
+    topicId: args.scope.topicId,
+    projectId: args.scope.projectId,
+    tenantId: args.scope.tenantId,
+    workspaceId: args.scope.workspaceId,
+    nodeType: "belief",
+    canonicalText: args.args.formulation,
+    contentHash: generateContentHash(args.args.formulation),
+    status: "active",
+    epistemicLayer: "L3",
+    sourceType: args.args.userId.startsWith("agent:") ? "ai_generated" : "human",
+    ...args.normalizedBeliefType ? { beliefType: args.normalizedBeliefType } : {},
+    createdAt: args.now,
+    updatedAt: args.now,
+    createdBy: args.args.userId,
+    ...args.seedOpinion,
+    tupleContradicted: false,
+    metadata: buildInternalBeliefMetadata(args.args, args.normalizedBeliefType)
+  };
+}
+function buildInternalBeliefMetadata(args, normalizedBeliefType) {
+  return {
+    ...args.confidence ? { confidence: args.confidence } : {},
+    tupleContradicted: false,
+    rationale: args.rationale || "",
+    topic: args.topic || args.pillar || "",
+    pillar: args.pillar || args.topic || "",
+    category: args.category || "",
+    subcategory: args.subcategory || "",
+    categoryIcon: args.categoryIcon || "",
+    sprintId: args.sprintId,
+    sourceBeliefIds: args.sourceBeliefIds || [],
+    criticality: args.criticality || "unanalyzed",
+    ...normalizedBeliefType ? { beliefType: normalizedBeliefType } : {},
+    supportingEvidenceIds: [],
+    contradictingEvidenceIds: [],
+    testingQuestionIds: [],
+    linkedInsightIds: [],
+    ...isRecord2(args.extraMetadata) ? args.extraMetadata : {}
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function insertInternalBeliefConfidence(ctx, args) {
+  await ctx.db.insert(
+    "beliefConfidence",
+    buildBeliefConfidenceRow({
+      beliefId: args.nodeId,
+      belief: args.seedOpinion.opinion_b,
+      disbelief: args.seedOpinion.opinion_d,
+      uncertainty: args.seedOpinion.opinion_u,
+      baseRate: args.baseRate,
+      trigger: "initial",
+      rationale: "LKC-2 mandatory prior: seeded vacuous opinion at belief creation.",
+      assessedBy: args.args.userId,
+      assessedAt: args.now,
+      slOperator: "prior_seed"
+    })
+  );
+}
+async function scheduleInternalBeliefSideEffects(ctx, args) {
+  await scheduleInternalNeo4jSync(ctx, args.nodeId);
+  await insertInternalBeliefAudit(ctx, args);
+  await scheduleInternalBeliefEmbedding(ctx, args);
+  await scheduleInternalBeliefCategorization(ctx, args);
+  await markBeliefGraphDirty(ctx, {
+    projectId: args.scope.projectId,
+    topicId: String(args.scope.topicId)
+  });
+}
+async function scheduleInternalNeo4jSync(ctx, nodeId) {
+  await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+    nodeId,
+    operation: "upsert"
+  });
+}
+async function insertInternalBeliefAudit(ctx, args) {
+  await ctx.db.insert("epistemicAudit", {
+    entityType: "belief",
+    entityId: args.nodeId,
+    changeType: "created",
+    changedAt: args.now,
+    changedBy: args.args.userId,
+    isAgent: false,
+    newState: {
+      formulation: args.args.formulation,
+      baseRate: args.baseRate,
+      confidence: args.args.confidence,
+      opinion: {
+        b: args.seedOpinion.opinion_b,
+        d: args.seedOpinion.opinion_d,
+        u: args.seedOpinion.opinion_u,
+        a: args.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: scope.topicId ? String(scope.topicId) : void 0,
-          createdBy: args.userId,
-          nodeType: "belief",
-          text: args.rationale ? `${args.formulation}
+      tupleContradicted: false,
+      source: "internal"
+    },
+    projectId: args.scope.projectId,
+    topicId: String(args.scope.topicId)
+  });
+}
+async function scheduleInternalBeliefEmbedding(ctx, args) {
+  if (!(args.scope.projectId || args.scope.topicId)) {
+    return;
+  }
+  await ctx.scheduler.runAfter(0, EMBEDDING_GENERATION_ACTION, {
+    nodeId: args.nodeId,
+    projectId: args.scope.projectId,
+    topicId: args.scope.topicId ? String(args.scope.topicId) : void 0,
+    createdBy: args.args.userId,
+    nodeType: "belief",
+    text: buildBeliefEmbeddingText(args.args),
+    ...args.args.confidence ? { confidence: numericRequestedConfidence(args.args.confidence) } : {}
+  });
+}
+function buildBeliefEmbeddingText(args) {
+  return args.rationale ? `${args.formulation}
 
-Rationale: ${args.rationale}` : args.formulation,
-          ...requestedConfidence ? {
-            confidence: requestedConfidence === "high" ? 0.8 : requestedConfidence === "low" ? 0.3 : 0.5
-          } : {}
-        }
-      );
-    }
-    if (normalizePillar(args.pillar || args.topic) === "other" && (scope.projectId || scope.topicId)) {
-      await ctx.scheduler.runAfter(
-        2500,
-        "beliefCategorization:autoCategorizeBelief",
-        {
-          nodeId,
-          projectId: scope.projectId,
-          topicId: String(scope.topicId)
-        }
-      );
-    }
-    await markBeliefGraphDirty(ctx, {
-      projectId: scope.projectId,
-      topicId: String(scope.topicId)
-    });
-    return { nodeId };
+Rationale: ${args.rationale}` : args.formulation;
+}
+function numericRequestedConfidence(confidence) {
+  if (confidence === "high") {
+    return 0.8;
   }
-});
+  if (confidence === "low") {
+    return 0.3;
+  }
+  return 0.5;
+}
+async function scheduleInternalBeliefCategorization(ctx, args) {
+  if (normalizePillar(args.args.pillar || args.args.topic) !== "other" || !(args.scope.projectId || args.scope.topicId)) {
+    return;
+  }
+  await ctx.scheduler.runAfter(2500, BELIEF_CATEGORIZATION_ACTION, {
+    nodeId: args.nodeId,
+    projectId: args.scope.projectId,
+    topicId: String(args.scope.topicId)
+  });
+}
 
 export { internalCreate, internalGetActive, internalGetById, internalGetByProject, internalGetByTopic };
 //# sourceMappingURL=epistemicBeliefs.internal.js.map