@lucern/graph-primitives 1.0.0 → 1.0.1

package/dist/epistemicEdges.js

@@ -3,13 +3,7 @@ import { checkScopeAccess, requireProjectAccess } from '@lucern/access-control/a
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
 import { componentsGeneric, anyApi, queryGeneric, mutationGeneric, internalMutationGeneric } from 'convex/server';
 
-// src/epistemicEdges.ts
-var api = anyApi;
-componentsGeneric();
-var internal = anyApi;
-var internalMutation = internalMutationGeneric;
-var mutation = mutationGeneric;
-var query = queryGeneric;
+// src/epistemicEdges.queries.ts
 
 // src/debug.ts
 function isGraphPrimitiveDebugEnabled() {
@@ -22,6 +16,167 @@ function debugGraphPrimitiveFallback(message, context) {
   }
   console.debug(message, context ?? {});
 }
+var api = anyApi;
+componentsGeneric();
+var internal = anyApi;
+var internalMutation = internalMutationGeneric;
+var mutation = mutationGeneric;
+var query = queryGeneric;
+var epistemicLayerValidator = v.union(
+  v.literal("L4"),
+  v.literal("L3"),
+  v.literal("L2"),
+  v.literal("L1"),
+  v.literal("ontological"),
+  v.literal("organizational")
+);
+var subjectiveOpinionValidator = v.object({
+  b: v.number(),
+  d: v.number(),
+  u: v.number(),
+  a: v.number()
+});
+var edgeTypeValidator = v.union(
+  // --- L4 Decision Edges (Phase 2A) ---
+  v.literal("based_on_belief"),
+  v.literal("based_on_question"),
+  v.literal("blocked_by_contradiction"),
+  v.literal("informed_by_theme"),
+  // --- Evidence Flow (L2 → L3, L2 → L1) ---
+  v.literal("derived_from"),
+  v.literal("responds_to"),
+  v.literal("informs"),
+  v.literal("tests"),
+  v.literal("explores"),
+  v.literal("qualifies"),
+  // --- Synthesis (L2 → L2, L2 → L1) ---
+  // "based_on" removed — use "derived_from" instead
+  // --- Theme Relationships (L3 → L3) ---
+  v.literal("relates_to_thesis"),
+  v.literal("belongs_to"),
+  v.literal("plays_theme"),
+  v.literal("scoped_by"),
+  // --- Deal/Company ---
+  v.literal("evaluates"),
+  // --- People (ontological → ontological, ontological → L3) ---
+  v.literal("perspective_on"),
+  v.literal("works_at"),
+  v.literal("mentioned_in"),
+  v.literal("founded_by"),
+  // --- Value Chain (ontological → ontological) ---
+  v.literal("participates_in"),
+  v.literal("performs"),
+  v.literal("function_in"),
+  v.literal("impacts"),
+  // --- Investment (ontological → ontological) ---
+  v.literal("invested_in"),
+  v.literal("raised_from"),
+  // --- Lifecycle (same layer only) ---
+  v.literal("supersedes"),
+  v.literal("same_as"),
+  // --- Same-Type Relationships: Belief ↔ Belief (L3 → L3) ---
+  v.literal("depends_on"),
+  v.literal("supports"),
+  v.literal("contains"),
+  // --- Belief Cluster Mapping (L3 → L3) ---
+  v.literal("counterfactual_of"),
+  v.literal("cascade_to"),
+  v.literal("cascade_from"),
+  v.literal("mutually_exclusive"),
+  v.literal("correlates_with"),
+  v.literal("amplifies"),
+  v.literal("precondition_for"),
+  v.literal("in_tension_with"),
+  // --- Belief ↔ Belief: Epistemic Impact (Confidence Propagation) ---
+  v.literal("falsified_by"),
+  v.literal("exclusive_with"),
+  v.literal("contradicts"),
+  v.literal("collapses_if"),
+  v.literal("strengthened_by"),
+  v.literal("weakened_by"),
+  v.literal("alternative_to"),
+  v.literal("subsumes"),
+  v.literal("validated_by"),
+  v.literal("required_for"),
+  v.literal("blocks"),
+  // --- Same-Type Relationships: Question ↔ Question (L3 → L3) ---
+  v.literal("prerequisite_for"),
+  v.literal("parallel_to"),
+  // --- Same-Type Relationships: Evidence ↔ Evidence (L2 → L2) ---
+  v.literal("corroborates"),
+  v.literal("extends"),
+  v.literal("same_source_as"),
+  v.literal("same_theme_as"),
+  // --- NEW: Deep Epistemic Analysis Edges (Phase: Schema Upgrade) ---
+  v.literal("assumes"),
+  v.literal("would_predict"),
+  v.literal("analogous_to"),
+  v.literal("independent_of"),
+  // --- Entity↔Belief Bridge (OE-B) ---
+  v.literal("competes_with")
+);
+function buildEdgeStatusSuccessResult() {
+  return { success: true };
+}
+function buildEdgeNotFoundResult() {
+  const result = {};
+  result.success = false;
+  result.error = "Edge not found";
+  return result;
+}
+function buildEdgeMirrorSkippedResult() {
+  return {
+    success: false,
+    reason: "source_not_in_convex"
+  };
+}
+function buildEdgeMirrorMissingResult() {
+  return {
+    success: false,
+    reason: "not_found"
+  };
+}
+function buildEdgeMirrorWriteResult(edgeId, existed) {
+  return {
+    success: true,
+    edgeId,
+    existed
+  };
+}
+function edgeMatchesWorkspaceReasoningScope(edge, scope) {
+  return scope.topicId !== void 0 && edge.topicId === scope.topicId || scope.projectId !== void 0 && edge.projectId === scope.projectId;
+}
+async function collectScopedEdges(ctx, scope, scanLimit) {
+  const queries = [];
+  if (scope.topicId) {
+    queries.push(
+      ctx.db.query("epistemicEdges").withIndex(
+        "by_topic",
+        (q) => q.eq("topicId", scope.topicId)
+      ).order("desc").take(scanLimit)
+    );
+  }
+  if (scope.projectId) {
+    queries.push(
+      ctx.db.query("epistemicEdges").withIndex(
+        "by_topic",
+        (q) => q.eq("topicId", scope.projectId)
+      ).order("desc").take(scanLimit)
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  const flattened = (await Promise.all(queries)).flat();
+  for (const edge of flattened) {
+    const key = String(edge._id);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(edge);
+  }
+  return deduped;
+}
 
 // src/graphTypes.ts
 var EDGE_TYPE_TO_REL = {
@@ -360,508 +515,181 @@ function validateEdgeLayers(edgeType, fromLayer, toLayer) {
   }
   return { valid: true };
 }
-
-// src/topicProjectOverlay.ts
 var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
-function readNonEmptyString(value) {
-  if (typeof value !== "string") {
+function asMappedProjectId(topic) {
+  if (!topic) {
     return;
   }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : void 0;
-}
-function readStringArray(value) {
-  if (!Array.isArray(value)) {
-    return [];
+  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
   }
-  return value.map((entry) => readNonEmptyString(entry)).filter((entry) => Boolean(entry));
-}
-function readMetadata(topic) {
-  return topic.metadata && typeof topic.metadata === "object" ? topic.metadata : {};
+  const metadata = topic.metadata || {};
+  const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
+  return candidate ? candidate : void 0;
 }
-function readLegacyProjectId(value) {
-  if (!value) {
+function normalizeScopeValue(value) {
+  if (typeof value !== "string") {
     return;
   }
-  return readNonEmptyString(value[LEGACY_SCOPE_FIELD]);
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
 }
-function coerceVisibility(value) {
-  return value === "private" || value === "team" || value === "firm" || value === "external" || value === "public" ? value : 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];
 }
-function coerceStatus(value) {
-  return value === "active" || value === "archived" || value === "watching" ? value : void 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;
+    });
+  }
 }
-function mapProjectType(topic, metadata) {
-  const explicit = readNonEmptyString(metadata.projectType);
-  if (explicit) {
-    return explicit;
+async function tryResolveHostTopicById(ctx, topicId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
   }
-  if (topic.type === "theme") {
-    return "thematic";
+  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;
   }
-  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
-        }
-      );
-    }
-  }
+async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
   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;
-    }
+    return await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: legacyScopeId
+    }) ?? null;
   } catch (error) {
     debugGraphPrimitiveFallback(
-      "[topicProjectOverlay] Failed to resolve topic by ID query",
+      "[topicScope] Failed to resolve topic by legacy scope",
       {
         error,
-        scopeId
+        legacyScopeId
       }
     );
+    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;
-    }
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicProjectOverlay] Failed to resolve topic by legacy scope ID",
-      { error, scopeId }
-    );
-  }
-  return null;
-}
-function materializeTopicProjectOverlay(topic, idMode = "legacy") {
-  const metadata = readMetadata(topic);
-  const topicId = String(topic._id);
-  const legacyProjectId = readLegacyProjectId(topic) || readLegacyProjectId(metadata) || readNonEmptyString(metadata.legacyProjectId);
-  const storageProjectId = legacyProjectId || topicId;
-  const outwardId = idMode === "topic" ? topicId : storageProjectId;
-  const visibility = coerceVisibility(topic.visibility) || coerceVisibility(metadata.visibility) || "private";
-  const status = coerceStatus(topic.status) || coerceStatus(metadata.status) || "active";
-  const createdAt = typeof topic.createdAt === "number" ? topic.createdAt : typeof topic._creationTime === "number" ? topic._creationTime : 0;
-  const updatedAt = typeof topic.updatedAt === "number" ? topic.updatedAt : typeof metadata.updatedAt === "number" ? metadata.updatedAt : createdAt;
-  return {
-    ...metadata,
-    _id: outwardId,
-    projectId: outwardId,
-    topicId,
-    storageProjectId,
-    legacyProjectId,
-    name: readNonEmptyString(topic.name) || "Untitled Theme",
-    type: mapProjectType(topic, metadata),
-    description: readNonEmptyString(topic.description),
-    ownerId: readNonEmptyString(metadata.ownerId) || readNonEmptyString(topic.createdBy) || "system",
-    sharedWith: readStringArray(metadata.sharedWith),
-    visibility,
-    tenantId: readNonEmptyString(topic.tenantId) || readNonEmptyString(metadata.tenantId),
-    workspaceId: readNonEmptyString(topic.workspaceId) || readNonEmptyString(metadata.workspaceId),
-    status,
-    tags: readStringArray(metadata.tags),
-    chatCount: typeof metadata.chatCount === "number" ? metadata.chatCount : 0,
-    artifactCount: typeof metadata.artifactCount === "number" ? metadata.artifactCount : 0,
-    lastActivityAt: typeof metadata.lastActivityAt === "number" ? metadata.lastActivityAt : updatedAt,
-    _creationTime: typeof topic._creationTime === "number" ? topic._creationTime : createdAt,
-    createdAt,
-    updatedAt
-  };
 }
-async function resolveTopicProjectOverlay(ctx, scopeId, options = {}) {
-  const topic = await resolveTopicDoc(ctx, scopeId);
-  if (!topic) {
-    return null;
+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 (options.projectLikeOnly !== false && !isProjectLikeTopic(topic)) {
-    return null;
+  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 materializeTopicProjectOverlay(topic, options.idMode);
+  return { tenantId, workspaceId };
 }
-async function listTopicProjectOverlays(ctx, options = {}) {
-  let allTopics = [];
-  if (ctx?.db?.query && typeof ctx.db.query === "function") {
+async function resolveTopicProjectScope(ctx, args) {
+  if (args.topicId) {
+    let topic = null;
     try {
-      allTopics = await ctx.db.query("topics").collect();
+      topic = await ctx.db.get(
+        args.topicId
+      );
     } catch (error) {
       debugGraphPrimitiveFallback(
-        "[topicProjectOverlay] Failed to read topics table; falling back to API",
-        { error }
+        "[topicScope] Failed to load topic by direct id",
+        {
+          error,
+          topicId: args.topicId
+        }
       );
-      allTopics = [];
     }
-  }
-  if (allTopics.length === 0 && typeof ctx.runQuery === "function") {
-    allTopics = (await ctx.runQuery(api.topics.list, {}) ?? []) || [];
-  }
-  return allTopics.filter(
-    (topic) => options.projectLikeOnly === false || isProjectLikeTopic(topic)
-  ).map((topic) => materializeTopicProjectOverlay(topic, options.idMode));
-}
-async function patchTopicProjectOverlay(ctx, scopeId, value) {
-  const topic = await resolveTopicDoc(ctx, scopeId);
-  if (!topic) {
-    return null;
-  }
-  const nextMetadata = { ...readMetadata(topic) };
-  const patch = {};
-  const topicUpdateArgs = {
-    id: String(topic._id)
-  };
-  for (const [key, rawValue] of Object.entries(value)) {
-    switch (key) {
-      case "_id":
-      case "projectId":
-      case "topicId":
-      case "legacyProjectId":
-      case "storageProjectId":
-        break;
-      case "name":
-      case "description":
-        patch[key] = rawValue;
-        topicUpdateArgs[key] = rawValue;
-        break;
-      case "tenantId":
-      case "workspaceId":
-      case "ownerId":
-        throw new Error(
-          `patchTopicProjectOverlay cannot mutate ${key} via component-owned topics`
-        );
-      case "status": {
-        const status = coerceStatus(rawValue);
-        if (status) {
-          patch.status = status;
-          topicUpdateArgs.status = status;
-        }
-        break;
-      }
-      case "visibility": {
-        const visibility = coerceVisibility(rawValue);
-        if (visibility) {
-          patch.visibility = visibility;
-          topicUpdateArgs.visibility = visibility;
-        }
-        break;
-      }
-      case "type": {
-        const projectType = readNonEmptyString(rawValue);
-        if (projectType) {
-          nextMetadata.projectType = projectType;
-        } else {
-          delete nextMetadata.projectType;
-        }
-        break;
-      }
-      case "updatedAt":
-      case "createdAt":
-        break;
-      default:
-        if (rawValue === void 0) {
-          delete nextMetadata[key];
-        } else {
-          nextMetadata[key] = rawValue;
-        }
+    if (!topic) {
+      topic = await tryResolveHostTopicById(ctx, String(args.topicId));
+    }
+    if (!topic) {
+      topic = pickPrimaryTopic(
+        await findTopicsByScopeAlias(ctx, String(args.topicId))
+      ) ?? null;
+    }
+    if (!topic) {
+      throw new Error(`Topic not found: ${String(args.topicId)}`);
+    }
+    const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
+    const mapped = asMappedProjectId(topic);
+    if (mapped) {
+      return {
+        topicId: topic._id,
+        projectId: mapped,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "topic"
+      };
     }
+    return {
+      topicId: topic._id,
+      tenantId: inherited.tenantId,
+      workspaceId: inherited.workspaceId,
+      source: "topic"
+    };
   }
-  patch.updatedAt = Date.now();
-  patch.metadata = nextMetadata;
-  topicUpdateArgs.metadata = nextMetadata;
-  if (typeof ctx.runMutation === "function") {
+  if (args.projectId) {
+    let directTopic = null;
     try {
-      await ctx.runMutation(api.topics.update, topicUpdateArgs);
+      directTopic = await ctx.db.get(
+        args.projectId
+      );
     } catch (error) {
-      if (!isMissingLucernChildComponentError(error) || !ctx?.db || typeof ctx.db.patch !== "function") {
-        throw error;
-      }
-      await ctx.db.patch(String(topic._id), patch);
-    }
-  } else if (ctx?.db && typeof ctx.db.patch === "function") {
-    await ctx.db.patch(String(topic._id), patch);
-  } else {
-    throw new Error(
-      "Cannot patch topic without component adapter (ctx.runMutation unavailable)"
-    );
-  }
-  return materializeTopicProjectOverlay({
-    ...topic,
-    ...patch,
-    metadata: nextMetadata
-  });
-}
-
-// src/resolvers.ts
-function isMissingLucernChildComponentError2(error) {
-  const message = getErrorMessage2(error);
-  return message.includes(
-    'Child component ComponentName(Identifier("lucern")) not found'
-  ) || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
-}
-function getErrorMessage2(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message;
-  }
-  return "unknown error";
-}
-function isAdvisoryTopicPatch(value) {
-  const advisoryKeys = /* @__PURE__ */ new Set(["lastActivityAt", "updatedAt"]);
-  const keys = Object.keys(value);
-  return keys.length > 0 && keys.every((key) => advisoryKeys.has(key));
-}
-async function patchProjectWithTolerance(ctx, projectId, value) {
-  try {
-    await patchTopicProjectOverlay(ctx, projectId, value);
-  } catch (error) {
-    if (!isAdvisoryTopicPatch(value) || !isMissingLucernChildComponentError2(error)) {
-      throw error;
-    }
-    console.warn(
-      "[lucern graph-primitives] Non-fatal advisory topic patch failure",
-      {
-        projectId,
-        keys: Object.keys(value),
-        error: getErrorMessage2(error)
-      }
-    );
-  }
-}
-function defaultResolvers() {
-  return {
-    getProject: (ctx, projectId) => resolveTopicProjectOverlay(ctx, projectId, {
-      idMode: "legacy",
-      projectLikeOnly: false
-    }),
-    patchProject: (ctx, projectId, value) => patchProjectWithTolerance(ctx, projectId, value),
-    listTopics: (ctx) => listTopicProjectOverlays(ctx, {
-      idMode: "legacy"
-    }),
-    getFinalArtifact: (ctx, artifactId) => ctx.db.get(artifactId)
-  };
-}
-var resolverOverrides = {};
-function resolveGraphPrimitivesAppResolvers(_ctx) {
-  return {
-    ...defaultResolvers(),
-    ...resolverOverrides
-  };
-}
-var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
-function asMappedProjectId(topic) {
-  if (!topic) {
-    return;
-  }
-  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD2]);
-  if (directLegacyProjectId) {
-    return directLegacyProjectId;
-  }
-  const metadata = topic.metadata || {};
-  const candidate = metadata[LEGACY_SCOPE_FIELD2] || 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_FIELD2, scopeId)
-    ).collect();
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve scope alias via index",
-      {
-        error,
-        scopeId
-      }
-    );
-    const topics = await ctx.db.query("topics").collect();
-    return topics.filter((topic) => {
-      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
-      const mappedProjectId = asMappedProjectId(topic);
-      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
-    });
-  }
-}
-async function tryResolveHostTopicById(ctx, topicId) {
-  if (typeof ctx.runQuery !== "function") {
-    return null;
-  }
-  try {
-    return await ctx.runQuery(api.topics.get, {
-      id: topicId
-    }) ?? null;
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve topic by host query",
-      {
-        error,
-        topicId
-      }
-    );
-    return null;
-  }
-}
-async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
-  if (typeof ctx.runQuery !== "function") {
-    return null;
-  }
-  try {
-    return await ctx.runQuery(api.topics.getByLegacyScopeId, {
-      projectId: legacyScopeId
-    }) ?? null;
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve topic by legacy scope",
-      {
-        error,
-        legacyScopeId
-      }
-    );
-    return null;
-  }
-}
-async function resolveInheritedWorkspaceScope(ctx, topic) {
-  const MAX_DEPTH = 10;
-  let tenantId = normalizeScopeValue(topic.tenantId);
-  let workspaceId = normalizeScopeValue(topic.workspaceId);
-  if (tenantId && workspaceId) {
-    return { tenantId, workspaceId };
-  }
-  let current = topic;
-  for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
-    current = await ctx.db.get(current.parentTopicId);
-    if (!current) break;
-    if (!tenantId) {
-      tenantId = normalizeScopeValue(current.tenantId);
-    }
-    if (!workspaceId) {
-      workspaceId = normalizeScopeValue(current.workspaceId);
-    }
-    if (tenantId && workspaceId) break;
-  }
-  return { tenantId, workspaceId };
-}
-async function resolveTopicProjectScope(ctx, args) {
-  if (args.topicId) {
-    let topic = null;
-    try {
-      topic = await ctx.db.get(
-        args.topicId
-      );
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load topic by direct id",
-        {
-          error,
-          topicId: args.topicId
-        }
-      );
-    }
-    if (!topic) {
-      topic = await tryResolveHostTopicById(ctx, String(args.topicId));
-    }
-    if (!topic) {
-      topic = pickPrimaryTopic(
-        await findTopicsByScopeAlias(ctx, String(args.topicId))
-      ) ?? null;
-    }
-    if (!topic) {
-      throw new Error(`Topic not found: ${String(args.topicId)}`);
-    }
-    const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
-    const mapped = asMappedProjectId(topic);
-    if (mapped) {
-      return {
-        topicId: topic._id,
-        projectId: mapped,
-        tenantId: inherited.tenantId,
-        workspaceId: inherited.workspaceId,
-        source: "topic"
-      };
-    }
-    return {
-      topicId: topic._id,
-      tenantId: inherited.tenantId,
-      workspaceId: inherited.workspaceId,
-      source: "topic"
-    };
-  }
-  if (args.projectId) {
-    let directTopic = null;
-    try {
-      directTopic = await ctx.db.get(
-        args.projectId
-      );
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicScope] Failed to load direct project topic",
-        {
-          error,
-          projectId: args.projectId
-        }
-      );
+      debugGraphPrimitiveFallback(
+        "[topicScope] Failed to load direct project topic",
+        {
+          error,
+          projectId: args.projectId
+        }
+      );
     }
     if (directTopic) {
       const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
@@ -911,191 +739,7 @@ var optionalScopeArgs = {
   topicId: v.optional(v.string())
 };
 
-// src/epistemicEdges.ts
-var epistemicLayerValidator = v.union(
-  v.literal("L4"),
-  v.literal("L3"),
-  v.literal("L2"),
-  v.literal("L1"),
-  v.literal("ontological"),
-  v.literal("organizational")
-);
-var subjectiveOpinionValidator = v.object({
-  b: v.number(),
-  d: v.number(),
-  u: v.number(),
-  a: v.number()
-});
-var edgeTypeValidator = v.union(
-  // --- L4 Decision Edges (Phase 2A) ---
-  v.literal("based_on_belief"),
-  // Decision → Belief (L4 → L3)
-  v.literal("based_on_question"),
-  // Decision → Question (L4 → L3)
-  v.literal("blocked_by_contradiction"),
-  // Decision → Contradiction (L4 → L3)
-  v.literal("informed_by_theme"),
-  // Decision → Theme (L4 → L3)
-  // --- Evidence Flow (L2 → L3, L2 → L1) ---
-  v.literal("derived_from"),
-  // Evidence/Synthesis → Source/Question (provenance)
-  v.literal("responds_to"),
-  // Answer → Question (L2 → L3)
-  v.literal("informs"),
-  // Evidence → Belief (L2 → L3) - use weight: -1 to +1
-  v.literal("tests"),
-  // Question → Belief (L3 → L3)
-  v.literal("explores"),
-  // Question → Belief assumption (L3 → L3)
-  v.literal("qualifies"),
-  // Evidence → Belief (L2 → L3)
-  // --- Synthesis (L2 → L2, L2 → L1) ---
-  // "based_on" removed — use "derived_from" instead
-  // --- Theme Relationships (L3 → L3) ---
-  v.literal("relates_to_thesis"),
-  // Belief → Theme (L3 → L3) - use weight: -1 to +1
-  v.literal("belongs_to"),
-  // Any → Theme (? → L3)
-  v.literal("plays_theme"),
-  // Deal → Theme (L3 → L3)
-  v.literal("scoped_by"),
-  // Belief/Question → Topic (L3 → organizational)
-  // --- Deal/Company ---
-  v.literal("evaluates"),
-  // Deal → Company (L3 → ontological)
-  // --- People (ontological → ontological, ontological → L3) ---
-  v.literal("perspective_on"),
-  // Person → Belief/Theme
-  v.literal("works_at"),
-  // Person → Company/Investor
-  v.literal("mentioned_in"),
-  // Person/Company → Source (ontological → L1)
-  v.literal("founded_by"),
-  // Company → Person (ontological → ontological)
-  // --- Value Chain (ontological → ontological) ---
-  v.literal("participates_in"),
-  // Company → ValueChain
-  v.literal("performs"),
-  // Company → Function
-  v.literal("function_in"),
-  // Function → ValueChain
-  v.literal("impacts"),
-  // Theme → ValueChain (L3 → ontological)
-  // --- Investment (ontological → ontological) ---
-  v.literal("invested_in"),
-  // Investor → Company
-  v.literal("raised_from"),
-  // Company → Investor
-  // --- Lifecycle (same layer only) ---
-  v.literal("supersedes"),
-  // NewNode → OldNode (same layer)
-  v.literal("same_as"),
-  // Duplicate detection (same layer)
-  // --- Same-Type Relationships: Belief ↔ Belief (L3 → L3) ---
-  v.literal("depends_on"),
-  // Belief B requires Belief A to be true
-  v.literal("supports"),
-  // Beliefs strengthen each other (weight > 0)
-  v.literal("contains"),
-  // Parent contains child (hierarchical containment)
-  // --- Belief Cluster Mapping (L3 → L3) - For Thesis Validation Sprints ---
-  // These edge types capture the full range of belief-to-belief relationships
-  // needed for cluster mapping, confidence propagation, and thesis testing.
-  v.literal("counterfactual_of"),
-  // If A is TRUE, B FAILS (inverse dependency)
-  v.literal("cascade_to"),
-  // If B fails, A also fails (downstream impact)
-  v.literal("cascade_from"),
-  // Changes propagate from A to B (upstream dependency)
-  v.literal("mutually_exclusive"),
-  // A and B cannot BOTH be true (zero-sum)
-  v.literal("correlates_with"),
-  // A and B move together non-causally (observed pattern)
-  v.literal("amplifies"),
-  // A strengthens B unidirectionally (one-way boost)
-  v.literal("precondition_for"),
-  // A must validate before B can be tested (temporal)
-  v.literal("in_tension_with"),
-  // A and B pull opposite directions (soft conflict)
-  // --- Belief ↔ Belief: Epistemic Impact (Confidence Propagation) ---
-  v.literal("falsified_by"),
-  // If B is validated, A becomes false
-  v.literal("exclusive_with"),
-  // A XOR B (sum of confidences ≤ 1)
-  v.literal("contradicts"),
-  // A directly contradicts B
-  v.literal("collapses_if"),
-  // If A falls below threshold, B collapses
-  v.literal("strengthened_by"),
-  // If A rises, B rises
-  v.literal("weakened_by"),
-  // If A rises, B falls
-  v.literal("alternative_to"),
-  // Competing explanations
-  v.literal("subsumes"),
-  // A is more general, includes B
-  v.literal("validated_by"),
-  // If B is true, A gains confidence
-  v.literal("required_for"),
-  // A must be true for B to be meaningful
-  v.literal("blocks"),
-  // A being unresolved blocks B
-  // --- Same-Type Relationships: Question ↔ Question (L3 → L3) ---
-  v.literal("prerequisite_for"),
-  // Question A must be answered first
-  v.literal("parallel_to"),
-  // Same topic, different angles
-  // --- Same-Type Relationships: Evidence ↔ Evidence (L2 → L2) ---
-  v.literal("corroborates"),
-  // Independent support for same conclusion
-  v.literal("extends"),
-  // Adds depth to other evidence
-  v.literal("same_source_as"),
-  // Same document/study
-  v.literal("same_theme_as"),
-  // Same topic/entity
-  // --- NEW: Deep Epistemic Analysis Edges (Phase: Schema Upgrade) ---
-  v.literal("assumes"),
-  // Hidden dependency discovered by AI (Belief B implicitly assumes A)
-  v.literal("would_predict"),
-  // Pre-registered prediction for validation (If Belief true, expect Evidence)
-  v.literal("analogous_to"),
-  // Explicit analogy with disanalogies (Belief A like Belief B because...)
-  v.literal("independent_of"),
-  // True evidence independence marker (Evidence A independent of B)
-  // --- Entity↔Belief Bridge (OE-B) ---
-  // "about_entity" and "entity_referenced_in" removed — use "contains" instead
-  v.literal("competes_with")
-  // Company → Company (ontological → ontological)
-);
-function buildEdgeStatusSuccessResult() {
-  return { success: true };
-}
-function buildEdgeNotFoundResult() {
-  const result = {};
-  result.success = false;
-  result.error = "Edge not found";
-  return result;
-}
-function buildEdgeMirrorSkippedResult() {
-  return {
-    success: false,
-    reason: "source_not_in_convex"
-  };
-}
-function buildEdgeMirrorMissingResult() {
-  return {
-    success: false,
-    reason: "not_found"
-  };
-}
-function buildEdgeMirrorWriteResult(edgeId, existed) {
-  return {
-    success: true,
-    edgeId,
-    existed
-  };
-}
+// src/epistemicEdges.queries.ts
 var get = query({
   args: { edgeId: v.id("epistemicEdges") },
   returns: permissiveReturn,
@@ -1311,76 +955,504 @@ var getByProject = query({
     return edges.filter((edge) => edgeMatchesWorkspaceReasoningScope(edge, scope)).slice(0, pageSize);
   }
 });
-var getByTopic = getByProject;
-function dedupeWorkspaceEdges(edges) {
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const edge of edges) {
-    const key = String(edge._id);
-    if (seen.has(key)) {
-      continue;
+var listAll = query({
+  args: {
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const pageSize = Math.max(
+      1,
+      Math.min(Math.floor(args.limit ?? 5e3), 1e4)
+    );
+    return await ctx.db.query("epistemicEdges").order("desc").take(pageSize);
+  }
+});
+var findContradictions = query({
+  args: {
+    nodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_to_type",
+      (q) => q.eq("toNodeId", args.nodeId).eq("edgeType", "informs")
+    ).collect();
+    return edges.filter((e) => (e.weight ?? 0) < 0);
+  }
+});
+var findSupport = query({
+  args: {
+    nodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_to_type",
+      (q) => q.eq("toNodeId", args.nodeId).eq("edgeType", "informs")
+    ).collect();
+    return edges.filter((e) => (e.weight ?? 0) >= 0);
+  }
+});
+var getLineage = query({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    maxDepth: v.optional(v.number()),
+    // Phase 2D: Layer-aware traversal options
+    minLayer: v.optional(v.number()),
+    // 1=L1, 2=L2, 3=L3, 4=L4
+    maxLayer: v.optional(v.number()),
+    mode: v.optional(
+      v.union(
+        v.literal("anchor_down"),
+        v.literal("anchor_up"),
+        v.literal("same_layer"),
+        v.literal("decision_trace")
+      )
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const maxDepth = args.maxDepth ?? 10;
+    const mode = args.mode ?? "anchor_down";
+    const minLayer = args.minLayer ?? getDefaultMinLayer(mode);
+    const maxLayer = args.maxLayer ?? 4;
+    const lineage = [];
+    const visited = /* @__PURE__ */ new Set();
+    const startNode = await ctx.db.get(args.nodeId);
+    if (!startNode) {
+      return lineage;
+    }
+    const startLayer = startNode.epistemicLayer || getNodeLayer(startNode.nodeType);
+    const queue = [{ nodeId: args.nodeId, depth: 0, currentLayer: startLayer }];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current || current.depth >= maxDepth) {
+        continue;
+      }
+      const nodeIdStr = current.nodeId.toString();
+      if (visited.has(nodeIdStr)) {
+        continue;
+      }
+      visited.add(nodeIdStr);
+      const edges = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", current.nodeId)).collect();
+      const lineageEdges = edges.filter((e) => e.edgeType === "derived_from");
+      for (const edge of lineageEdges) {
+        if (!edge.toNodeId) {
+          continue;
+        }
+        const targetNode = await ctx.db.get(edge.toNodeId);
+        if (!targetNode || visited.has(edge.toNodeId.toString())) {
+          continue;
+        }
+        const targetLayer = edge.toLayer || targetNode.epistemicLayer || getNodeLayer(targetNode.nodeType);
+        const shouldContinue = shouldContinueTraversal(
+          current.currentLayer,
+          targetLayer,
+          { mode, minLayer, maxLayer }
+        );
+        if (!shouldContinue) {
+          continue;
+        }
+        lineage.push({
+          node: targetNode,
+          depth: current.depth + 1,
+          edgeType: edge.edgeType,
+          layer: targetLayer
+        });
+        queue.push({
+          nodeId: edge.toNodeId,
+          depth: current.depth + 1,
+          currentLayer: targetLayer
+        });
+      }
+    }
+    return lineage;
+  }
+});
+var getEvidenceForBelief = query({
+  args: {
+    beliefNodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const informsEdges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_to_type",
+      (q) => q.eq("toNodeId", args.beliefNodeId).eq("edgeType", "informs")
+    ).collect();
+    const supportEdges = informsEdges.filter((e) => (e.weight ?? 0) >= 0);
+    const contradictEdges = informsEdges.filter((e) => (e.weight ?? 0) < 0);
+    const supportingEvidence = await Promise.all(
+      supportEdges.map(async (edge) => ({
+        edge,
+        node: await ctx.db.get(edge.fromNodeId)
+      }))
+    );
+    const contradictingEvidence = await Promise.all(
+      contradictEdges.map(async (edge) => ({
+        edge,
+        node: await ctx.db.get(edge.fromNodeId)
+      }))
+    );
+    const filteredSupporting = supportingEvidence.filter((e) => e.node !== null);
+    const filteredContradicting = contradictingEvidence.filter(
+      (e) => e.node !== null
+    );
+    return {
+      supporting: filteredSupporting,
+      contradicting: filteredContradicting,
+      supportCount: filteredSupporting.length,
+      contradictCount: filteredContradicting.length
+    };
+  }
+});
+var getClusterEdges = query({
+  args: {
+    beliefIds: v.array(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    if (args.beliefIds.length === 0) {
+      return [];
+    }
+    const beliefIdSet = new Set(args.beliefIds);
+    const allEdges = await ctx.db.query("epistemicEdges").collect();
+    return allEdges.filter((edge) => {
+      const fromInCluster = beliefIdSet.has(String(edge.fromNodeId)) || edge.sourceGlobalId && beliefIdSet.has(edge.sourceGlobalId);
+      const toInCluster = beliefIdSet.has(String(edge.toNodeId)) || edge.targetGlobalId && beliefIdSet.has(edge.targetGlobalId);
+      return fromInCluster && toInCluster;
+    });
+  }
+});
+
+// src/topicProjectOverlay.ts
+var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
+function readNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => readNonEmptyString(entry)).filter((entry) => Boolean(entry));
+}
+function readMetadata(topic) {
+  return topic.metadata && typeof topic.metadata === "object" ? topic.metadata : {};
+}
+function readLegacyProjectId(value) {
+  if (!value) {
+    return;
+  }
+  return readNonEmptyString(value[LEGACY_SCOPE_FIELD2]);
+}
+function coerceVisibility(value) {
+  return value === "private" || value === "team" || value === "firm" || value === "external" || value === "public" ? value : void 0;
+}
+function coerceStatus(value) {
+  return value === "active" || value === "archived" || value === "watching" ? value : void 0;
+}
+function mapProjectType(topic, metadata) {
+  const explicit = readNonEmptyString(metadata.projectType);
+  if (explicit) {
+    return explicit;
+  }
+  if (topic.type === "theme") {
+    return "thematic";
+  }
+  return readNonEmptyString(topic.type) || "general";
+}
+function isProjectLikeTopic(topic) {
+  const metadata = readMetadata(topic);
+  return topic.type === "theme" || topic.type === "thematic" || topic.type === "deal" || topic.type === "monitoring" || readLegacyProjectId(topic) !== void 0 || readNonEmptyString(metadata.projectType) !== void 0;
+}
+function isMissingLucernChildComponentError(error) {
+  const message = getErrorMessage(error);
+  return message.includes(
+    'Child component ComponentName(Identifier("lucern")) not found'
+  ) || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return "unknown error";
+}
+async function resolveTopicDoc(ctx, scopeId) {
+  if (ctx?.db && typeof ctx.db.get === "function") {
+    try {
+      const directTopic = await ctx.db.get(
+        scopeId
+      );
+      if (directTopic) {
+        return directTopic;
+      }
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[topicProjectOverlay] Failed to resolve topic by direct ID",
+        {
+          error,
+          scopeId
+        }
+      );
+    }
+  }
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    const topic = await ctx.runQuery(api.topics.get, {
+      id: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicProjectOverlay] Failed to resolve topic by ID query",
+      {
+        error,
+        scopeId
+      }
+    );
+  }
+  try {
+    const topic = await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicProjectOverlay] Failed to resolve topic by legacy scope ID",
+      { error, scopeId }
+    );
+  }
+  return null;
+}
+function materializeTopicProjectOverlay(topic, idMode = "legacy") {
+  const metadata = readMetadata(topic);
+  const topicId = String(topic._id);
+  const legacyProjectId = readLegacyProjectId(topic) || readLegacyProjectId(metadata) || readNonEmptyString(metadata.legacyProjectId);
+  const storageProjectId = legacyProjectId || topicId;
+  const outwardId = idMode === "topic" ? topicId : storageProjectId;
+  const visibility = coerceVisibility(topic.visibility) || coerceVisibility(metadata.visibility) || "private";
+  const status = coerceStatus(topic.status) || coerceStatus(metadata.status) || "active";
+  const createdAt = typeof topic.createdAt === "number" ? topic.createdAt : typeof topic._creationTime === "number" ? topic._creationTime : 0;
+  const updatedAt = typeof topic.updatedAt === "number" ? topic.updatedAt : typeof metadata.updatedAt === "number" ? metadata.updatedAt : createdAt;
+  return {
+    ...metadata,
+    _id: outwardId,
+    projectId: outwardId,
+    topicId,
+    storageProjectId,
+    legacyProjectId,
+    name: readNonEmptyString(topic.name) || "Untitled Theme",
+    type: mapProjectType(topic, metadata),
+    description: readNonEmptyString(topic.description),
+    ownerId: readNonEmptyString(metadata.ownerId) || readNonEmptyString(topic.createdBy) || "system",
+    sharedWith: readStringArray(metadata.sharedWith),
+    visibility,
+    tenantId: readNonEmptyString(topic.tenantId) || readNonEmptyString(metadata.tenantId),
+    workspaceId: readNonEmptyString(topic.workspaceId) || readNonEmptyString(metadata.workspaceId),
+    status,
+    tags: readStringArray(metadata.tags),
+    chatCount: typeof metadata.chatCount === "number" ? metadata.chatCount : 0,
+    artifactCount: typeof metadata.artifactCount === "number" ? metadata.artifactCount : 0,
+    lastActivityAt: typeof metadata.lastActivityAt === "number" ? metadata.lastActivityAt : updatedAt,
+    _creationTime: typeof topic._creationTime === "number" ? topic._creationTime : createdAt,
+    createdAt,
+    updatedAt
+  };
+}
+async function resolveTopicProjectOverlay(ctx, scopeId, options = {}) {
+  const topic = await resolveTopicDoc(ctx, scopeId);
+  if (!topic) {
+    return null;
+  }
+  if (options.projectLikeOnly !== false && !isProjectLikeTopic(topic)) {
+    return null;
+  }
+  return materializeTopicProjectOverlay(topic, options.idMode);
+}
+async function listTopicProjectOverlays(ctx, options = {}) {
+  let allTopics = [];
+  if (ctx?.db?.query && typeof ctx.db.query === "function") {
+    try {
+      allTopics = await ctx.db.query("topics").collect();
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[topicProjectOverlay] Failed to read topics table; falling back to API",
+        { error }
+      );
+      allTopics = [];
+    }
+  }
+  if (allTopics.length === 0 && typeof ctx.runQuery === "function") {
+    allTopics = (await ctx.runQuery(api.topics.list, {}) ?? []) || [];
+  }
+  return allTopics.filter(
+    (topic) => options.projectLikeOnly === false || isProjectLikeTopic(topic)
+  ).map((topic) => materializeTopicProjectOverlay(topic, options.idMode));
+}
+async function patchTopicProjectOverlay(ctx, scopeId, value) {
+  const topic = await resolveTopicDoc(ctx, scopeId);
+  if (!topic) {
+    return null;
+  }
+  const nextMetadata = { ...readMetadata(topic) };
+  const patch = {};
+  const topicUpdateArgs = {
+    id: String(topic._id)
+  };
+  for (const [key, rawValue] of Object.entries(value)) {
+    switch (key) {
+      case "_id":
+      case "projectId":
+      case "topicId":
+      case "legacyProjectId":
+      case "storageProjectId":
+        break;
+      case "name":
+      case "description":
+        patch[key] = rawValue;
+        topicUpdateArgs[key] = rawValue;
+        break;
+      case "tenantId":
+      case "workspaceId":
+      case "ownerId":
+        throw new Error(
+          `patchTopicProjectOverlay cannot mutate ${key} via component-owned topics`
+        );
+      case "status": {
+        const status = coerceStatus(rawValue);
+        if (status) {
+          patch.status = status;
+          topicUpdateArgs.status = status;
+        }
+        break;
+      }
+      case "visibility": {
+        const visibility = coerceVisibility(rawValue);
+        if (visibility) {
+          patch.visibility = visibility;
+          topicUpdateArgs.visibility = visibility;
+        }
+        break;
+      }
+      case "type": {
+        const projectType = readNonEmptyString(rawValue);
+        if (projectType) {
+          nextMetadata.projectType = projectType;
+        } else {
+          delete nextMetadata.projectType;
+        }
+        break;
+      }
+      case "updatedAt":
+      case "createdAt":
+        break;
+      default:
+        if (rawValue === void 0) {
+          delete nextMetadata[key];
+        } else {
+          nextMetadata[key] = rawValue;
+        }
+    }
+  }
+  patch.updatedAt = Date.now();
+  patch.metadata = nextMetadata;
+  topicUpdateArgs.metadata = nextMetadata;
+  if (typeof ctx.runMutation === "function") {
+    try {
+      await ctx.runMutation(api.topics.update, topicUpdateArgs);
+    } catch (error) {
+      if (!isMissingLucernChildComponentError(error) || !ctx?.db || typeof ctx.db.patch !== "function") {
+        throw error;
+      }
+      await ctx.db.patch(String(topic._id), patch);
     }
-    seen.add(key);
-    deduped.push(edge);
+  } else if (ctx?.db && typeof ctx.db.patch === "function") {
+    await ctx.db.patch(String(topic._id), patch);
+  } else {
+    throw new Error(
+      "Cannot patch topic without component adapter (ctx.runMutation unavailable)"
+    );
   }
-  return deduped;
+  return materializeTopicProjectOverlay({
+    ...topic,
+    ...patch,
+    metadata: nextMetadata
+  });
 }
-function edgeMatchesWorkspaceReasoningScope(edge, scope) {
-  return scope.topicId !== void 0 && edge.topicId === scope.topicId || scope.projectId !== void 0 && edge.projectId === scope.projectId;
+
+// 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 collectScopedEdges(ctx, scope, scanLimit) {
-  const queries = [];
-  if (scope.topicId) {
-    queries.push(
-      ctx.db.query("epistemicEdges").withIndex("by_topic", (q) => q.eq("topicId", scope.topicId)).order("desc").take(scanLimit)
-    );
+function getErrorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
   }
-  if (scope.projectId) {
-    queries.push(
-      ctx.db.query("epistemicEdges").withIndex("by_topic", (q) => q.eq("topicId", scope.projectId)).order("desc").take(scanLimit)
-    );
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
   }
-  return dedupeWorkspaceEdges((await Promise.all(queries)).flat());
+  return "unknown error";
 }
-var listAll = query({
-  args: {
-    limit: v.optional(v.number())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const pageSize = Math.max(
-      1,
-      Math.min(Math.floor(args.limit ?? 5e3), 1e4)
+function isAdvisoryTopicPatch(value) {
+  const advisoryKeys = /* @__PURE__ */ new Set(["lastActivityAt", "updatedAt"]);
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((key) => advisoryKeys.has(key));
+}
+async function patchProjectWithTolerance(ctx, projectId, value) {
+  try {
+    await patchTopicProjectOverlay(ctx, projectId, value);
+  } catch (error) {
+    if (!isAdvisoryTopicPatch(value) || !isMissingLucernChildComponentError2(error)) {
+      throw error;
+    }
+    console.warn(
+      "[lucern graph-primitives] Non-fatal advisory topic patch failure",
+      {
+        projectId,
+        keys: Object.keys(value),
+        error: getErrorMessage2(error)
+      }
     );
-    return await ctx.db.query("epistemicEdges").order("desc").take(pageSize);
-  }
-});
-var findContradictions = query({
-  args: {
-    nodeId: v.id("epistemicNodes")
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const edges = await ctx.db.query("epistemicEdges").withIndex(
-      "by_to_type",
-      (q) => q.eq("toNodeId", args.nodeId).eq("edgeType", "informs")
-    ).collect();
-    return edges.filter((e) => (e.weight ?? 0) < 0);
-  }
-});
-var findSupport = query({
-  args: {
-    nodeId: v.id("epistemicNodes")
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const edges = await ctx.db.query("epistemicEdges").withIndex(
-      "by_to_type",
-      (q) => q.eq("toNodeId", args.nodeId).eq("edgeType", "informs")
-    ).collect();
-    return edges.filter((e) => (e.weight ?? 0) >= 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)
+  };
+}
+var resolverOverrides = {};
+function resolveGraphPrimitivesAppResolvers(_ctx) {
+  return {
+    ...defaultResolvers(),
+    ...resolverOverrides
+  };
+}
+
+// src/epistemicEdges.mutations.ts
 var create = mutation({
   args: {
     globalId: v.string(),
@@ -1390,12 +1462,9 @@ var create = mutation({
     weight: v.optional(v.number()),
     confidence: v.optional(v.number()),
     context: v.optional(v.string()),
-    // NOTE: 'relation' field has been removed. Use 'weight' instead.
     derivationType: v.optional(v.string()),
-    // For derived_from edges
     createdBy: v.string(),
     ...optionalScopeArgs,
-    // Phase 2C: Allow skipping validation for migrations
     skipLayerValidation: v.optional(v.boolean())
   },
   returns: permissiveReturn,
@@ -1486,10 +1555,8 @@ var update = mutation({
     weight: v.optional(v.number()),
     confidence: v.optional(v.number()),
     context: v.optional(v.string()),
-    // NOTE: 'relation' field has been removed. Use 'weight' instead.
     derivationType: v.optional(v.string()),
     userId: v.optional(v.string()),
-    // EK-4: SL opinion metadata (Kernel v2 schema fields)
     constraint: v.optional(v.string()),
     propagation: v.optional(v.string()),
     blocking: v.optional(v.boolean()),
@@ -1574,8 +1641,6 @@ var remove = mutation({
         },
         projectId: edge.projectId
       });
-    }
-    if (edge.projectId) {
       await resolveGraphPrimitivesAppResolvers().patchProject(
         ctx,
         edge.projectId,
@@ -1627,13 +1692,11 @@ var batchCreate = mutation({
         weight: v.optional(v.number()),
         confidence: v.optional(v.number()),
         context: v.optional(v.string()),
-        // NOTE: 'relation' field has been removed. Use 'weight' instead.
         derivationType: v.optional(v.string()),
         createdBy: v.string(),
         ...optionalScopeArgs
       })
     ),
-    // Phase 2C: Allow skipping validation for migrations
     skipLayerValidation: v.optional(v.boolean())
   },
   returns: permissiveReturn,
@@ -1653,11 +1716,7 @@ var batchCreate = mutation({
       const fromLayer = fromNode.epistemicLayer || getNodeLayer(fromNode.nodeType);
       const toLayer = toNode.epistemicLayer || getNodeLayer(toNode.nodeType);
       if (!args.skipLayerValidation) {
-        const validation = validateEdgeLayers(
-          edge.edgeType,
-          fromLayer,
-          toLayer
-        );
+        const validation = validateEdgeLayers(edge.edgeType, fromLayer, toLayer);
         if (!validation.valid) {
           errors.push({
             globalId: edge.globalId,
@@ -1706,132 +1765,14 @@ var batchCreate = mutation({
     return { created: results.length, results, errors };
   }
 });
-var getLineage = query({
-  args: {
-    nodeId: v.id("epistemicNodes"),
-    maxDepth: v.optional(v.number()),
-    // Phase 2D: Layer-aware traversal options
-    minLayer: v.optional(v.number()),
-    // 1=L1, 2=L2, 3=L3, 4=L4
-    maxLayer: v.optional(v.number()),
-    mode: v.optional(
-      v.union(
-        v.literal("anchor_down"),
-        v.literal("anchor_up"),
-        v.literal("same_layer"),
-        v.literal("decision_trace")
-      )
-    )
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const maxDepth = args.maxDepth ?? 10;
-    const mode = args.mode ?? "anchor_down";
-    const minLayer = args.minLayer ?? getDefaultMinLayer(mode);
-    const maxLayer = args.maxLayer ?? 4;
-    const lineage = [];
-    const visited = /* @__PURE__ */ new Set();
-    const startNode = await ctx.db.get(args.nodeId);
-    if (!startNode) {
-      return lineage;
-    }
-    const startLayer = startNode.epistemicLayer || getNodeLayer(startNode.nodeType);
-    const queue = [{ nodeId: args.nodeId, depth: 0, currentLayer: startLayer }];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (!current || current.depth >= maxDepth) {
-        continue;
-      }
-      const nodeIdStr = current.nodeId.toString();
-      if (visited.has(nodeIdStr)) {
-        continue;
-      }
-      visited.add(nodeIdStr);
-      const edges = await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", current.nodeId)).collect();
-      const lineageEdges = edges.filter((e) => e.edgeType === "derived_from");
-      for (const edge of lineageEdges) {
-        if (!edge.toNodeId) {
-          continue;
-        }
-        const targetNode = await ctx.db.get(edge.toNodeId);
-        if (!targetNode || visited.has(edge.toNodeId.toString())) {
-          continue;
-        }
-        const targetLayer = edge.toLayer || targetNode.epistemicLayer || getNodeLayer(targetNode.nodeType);
-        const shouldContinue = shouldContinueTraversal(
-          current.currentLayer,
-          targetLayer,
-          { mode, minLayer, maxLayer }
-        );
-        if (!shouldContinue) {
-          continue;
-        }
-        lineage.push({
-          node: targetNode,
-          depth: current.depth + 1,
-          edgeType: edge.edgeType,
-          layer: targetLayer
-        });
-        queue.push({
-          nodeId: edge.toNodeId,
-          depth: current.depth + 1,
-          currentLayer: targetLayer
-        });
-      }
-    }
-    return lineage;
-  }
-});
-var getEvidenceForBelief = query({
-  args: {
-    beliefNodeId: v.id("epistemicNodes")
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const informsEdges = await ctx.db.query("epistemicEdges").withIndex(
-      "by_to_type",
-      (q) => q.eq("toNodeId", args.beliefNodeId).eq("edgeType", "informs")
-    ).collect();
-    const supportEdges = informsEdges.filter((e) => (e.weight ?? 0) >= 0);
-    const contradictEdges = informsEdges.filter((e) => (e.weight ?? 0) < 0);
-    const supportingEvidence = await Promise.all(
-      supportEdges.map(async (edge) => ({
-        edge,
-        node: await ctx.db.get(edge.fromNodeId)
-      }))
-    );
-    const contradictingEvidence = await Promise.all(
-      contradictEdges.map(async (edge) => ({
-        edge,
-        node: await ctx.db.get(edge.fromNodeId)
-      }))
-    );
-    const filteredSupporting = supportingEvidence.filter(
-      (e) => e.node !== null
-    );
-    const filteredContradicting = contradictingEvidence.filter(
-      (e) => e.node !== null
-    );
-    return {
-      supporting: filteredSupporting,
-      contradicting: filteredContradicting,
-      supportCount: filteredSupporting.length,
-      contradictCount: filteredContradicting.length
-    };
-  }
-});
 var cleanupDeprecatedEdges = mutation({
   args: {
     ...optionalScopeArgs,
     dryRun: v.optional(v.boolean())
-    // If true, just reports what would be deleted
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const DEPRECATED_TYPES = [
-      "contradicts"
-      // Old generic contradict edge (use weight: -1 on informs)
-    ];
+    const DEPRECATED_TYPES = ["contradicts"];
     const scopeId = args.topicId || args.projectId;
     const allEdges = scopeId ? await ctx.db.query("epistemicEdges").withIndex("by_topic", (q) => q.eq("topicId", scopeId)).collect() : [];
     const deprecatedEdges = allEdges.filter(
@@ -1846,7 +1787,7 @@ var cleanupDeprecatedEdges = mutation({
           type: e.edgeType,
           from: e.fromNodeId,
           to: e.toNodeId,
-          description: e.context?.description || e.description
+          description: typeof e.context === "object" && e.context && "description" in e.context ? e.context.description : e.description
         })),
         message: `Would delete ${deprecatedEdges.length} deprecated edges`
       };
@@ -1895,24 +1836,6 @@ var deleteEdges = mutation({
     };
   }
 });
-var getClusterEdges = query({
-  args: {
-    beliefIds: v.array(v.string())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    if (args.beliefIds.length === 0) {
-      return [];
-    }
-    const beliefIdSet = new Set(args.beliefIds);
-    const allEdges = await ctx.db.query("epistemicEdges").collect();
-    return allEdges.filter((edge) => {
-      const fromInCluster = beliefIdSet.has(String(edge.fromNodeId)) || edge.sourceGlobalId && beliefIdSet.has(edge.sourceGlobalId);
-      const toInCluster = beliefIdSet.has(String(edge.toNodeId)) || edge.targetGlobalId && beliefIdSet.has(edge.targetGlobalId);
-      return fromInCluster && toInCluster;
-    });
-  }
-});
 var mirrorEdgeToConvex = internalMutation({
   args: {
     globalId: v.string(),
@@ -1929,7 +1852,6 @@ var mirrorEdgeToConvex = internalMutation({
     toLayer: v.optional(v.string()),
     fromNodeType: v.optional(v.string()),
     toNodeType: v.optional(v.string()),
-    // === CLASSIFICATION FIELDS ===
     reasoningMethod: v.optional(v.string()),
     logicalRole: v.optional(v.string()),
     temporalClass: v.optional(v.string()),
@@ -1962,11 +1884,9 @@ var mirrorEdgeToConvex = internalMutation({
       globalId: args.globalId,
       fromNodeId: fromNode._id,
       toNodeId: toNode?._id,
-      // Optional - may be undefined for cross-graph edges
       sourceGlobalId: args.fromGlobalId,
       targetGlobalId: args.toGlobalId,
-      // Cast through any because EdgeType may include types not yet in
-      // Convex _generated types (deployed schema lags source schema).
+      // Preserve the canonical string value even when the local schema lags.
       edgeType: args.edgeType,
       weight: args.weight,
       confidence: args.confidence,
@@ -1986,7 +1906,6 @@ var mirrorEdgeToConvex = internalMutation({
       toLayer: args.toLayer,
       fromNodeType: args.fromNodeType,
       toNodeType: args.toNodeType,
-      // Classification fields
       reasoningMethod: args.reasoningMethod,
       logicalRole: args.logicalRole,
       temporalClass: args.temporalClass,
@@ -2073,6 +1992,9 @@ var updateEdgeInConvex = internalMutation({
   }
 });
 
+// src/epistemicEdges.ts
+var getByTopic = getByProject;
+
 export { batchCreate, cleanupDeprecatedEdges, create, deleteEdgeFromConvex, deleteEdges, edgeTypeValidator, epistemicLayerValidator, findContradictions, findSupport, get, getBetween, getByGlobalId, getByNodes, getByProject, getByProjectAndType, getBySourceNode, getByTargetNode, getByTopic, getClusterEdges, getEvidenceForBelief, getFromNode, getLineage, getToNode, listAll, mirrorEdgeToConvex, remove, removeBetween, update, updateEdgeInConvex };
 //# sourceMappingURL=epistemicEdges.js.map
 //# sourceMappingURL=epistemicEdges.js.map