@lucern/graph-primitives 0.1.0-alpha.2

package/dist/epistemicEdges.js

@@ -0,0 +1,2749 @@
+import { v } from 'convex/values';
+import { componentsGeneric, queryGeneric, mutationGeneric, anyApi, internalMutationGeneric } from 'convex/server';
+
+// src/epistemicEdges.ts
+var api = anyApi;
+componentsGeneric();
+
+// ../access-control/src/topicProjectOverlay.ts
+var LEGACY_SCOPE_FIELD = "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_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;
+  }
+  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;
+}
+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 {
+    }
+  }
+  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 {
+  }
+  try {
+    const topic = await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch {
+  }
+  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 {
+      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));
+}
+
+// ../access-control/src/projectGrantsBridge.ts
+var PROJECT_GRANT_STATUSES = ["active", "revoked", "expired"];
+function normalizeString(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+async function resolveGrantScopeIds(ctx, args) {
+  const topicId = normalizeString(args.topicId);
+  const projectId = normalizeString(args.projectId);
+  for (const scopeId of [topicId, projectId]) {
+    if (!scopeId) {
+      continue;
+    }
+    try {
+      const overlay = await resolveTopicProjectOverlay(ctx, scopeId, {
+        idMode: "legacy",
+        projectLikeOnly: false
+      });
+      if (overlay) {
+        return {
+          topicId: normalizeString(overlay.topicId) ?? topicId,
+          projectId: normalizeString(overlay.projectId) ?? projectId ?? scopeId
+        };
+      }
+    } catch {
+    }
+  }
+  return { topicId, projectId };
+}
+async function normalizeProjectGrantRow(ctx, row) {
+  const scope = await resolveGrantScopeIds(ctx, {
+    topicId: row.topicId,
+    projectId: row.projectId
+  });
+  return {
+    ...row,
+    ...scope.topicId ? { topicId: scope.topicId } : {},
+    ...scope.projectId ?? scope.topicId ? { projectId: scope.projectId ?? scope.topicId } : {}
+  };
+}
+async function normalizeProjectGrantRows(ctx, rows) {
+  return await Promise.all(rows.map((row) => normalizeProjectGrantRow(ctx, row)));
+}
+async function listProjectGrantsByPrincipal(ctx, principalId) {
+  const rows = await Promise.all(
+    PROJECT_GRANT_STATUSES.map(
+      (status) => ctx.db.query("projectGrants").withIndex(
+        "by_principal_status",
+        (q) => q.eq("principalId", principalId).eq("status", status)
+      ).collect()
+    )
+  );
+  return await normalizeProjectGrantRows(ctx, rows.flat());
+}
+async function listProjectGrantsByGroup(ctx, groupId) {
+  const rows = await Promise.all(
+    PROJECT_GRANT_STATUSES.map(
+      (status) => ctx.db.query("projectGrants").withIndex(
+        "by_group_status",
+        (q) => q.eq("groupId", groupId).eq("status", status)
+      ).collect()
+    )
+  );
+  return await normalizeProjectGrantRows(ctx, rows.flat());
+}
+function buildScopeMatchers(inputScopeId, resolved) {
+  return new Set(
+    [inputScopeId, resolved.topicId, resolved.projectId].map((value) => normalizeString(value)).filter((value) => Boolean(value))
+  );
+}
+function matchesResolvedScope(row, scopeIds) {
+  const rowTopicId = normalizeString(row.topicId);
+  const rowProjectId = normalizeString(row.projectId);
+  return rowTopicId !== void 0 && scopeIds.has(rowTopicId) || rowProjectId !== void 0 && scopeIds.has(rowProjectId);
+}
+async function bridgeListProjectGrantsByTopicAndPrincipal(ctx, topicId, principalId) {
+  const resolved = await resolveGrantScopeIds(ctx, { topicId });
+  const scopeIds = buildScopeMatchers(topicId, resolved);
+  const rows = await listProjectGrantsByPrincipal(ctx, principalId);
+  return rows.filter((row) => matchesResolvedScope(row, scopeIds));
+}
+async function bridgeListProjectGrantsByTopicAndGroup(ctx, topicId, groupId) {
+  const resolved = await resolveGrantScopeIds(ctx, { topicId });
+  const scopeIds = buildScopeMatchers(topicId, resolved);
+  const rows = await listProjectGrantsByGroup(ctx, groupId);
+  return rows.filter((row) => matchesResolvedScope(row, scopeIds));
+}
+async function bridgeListProjectGrantsByPrincipalStatus(ctx, principalId, status) {
+  const rows = await listProjectGrantsByPrincipal(ctx, principalId);
+  return rows.filter((row) => row.status === status);
+}
+async function bridgeListProjectGrantsByGroupStatus(ctx, groupId, status) {
+  const rows = await listProjectGrantsByGroup(ctx, groupId);
+  return rows.filter((row) => row.status === status);
+}
+async function bridgeInsertProjectGrant(ctx, value) {
+  const resolved = await resolveGrantScopeIds(ctx, value);
+  return await ctx.db.insert("projectGrants", {
+    ...value,
+    ...resolved.topicId ? { topicId: resolved.topicId } : {},
+    ...resolved.projectId ?? resolved.topicId ? { projectId: resolved.projectId ?? resolved.topicId } : {}
+  });
+}
+
+// ../access-control/src/resolvers.ts
+async function findUserByClerkId(ctx, clerkId) {
+  const normalizedClerkId = clerkId.trim();
+  if (!normalizedClerkId) {
+    return null;
+  }
+  if (typeof ctx.runQuery === "function") {
+    try {
+      const bridgedUser = await ctx.runQuery(api.users.getUserByClerkId, {
+        clerkId: normalizedClerkId
+      });
+      if (bridgedUser) {
+        return bridgedUser;
+      }
+    } catch {
+    }
+  }
+  try {
+    const users = await ctx.db.query("users").collect();
+    return users.find((user) => String(user.clerkId ?? "") === normalizedClerkId) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function findUserByPrincipalId(ctx, principalId) {
+  const normalizedPrincipalId = principalId.trim();
+  if (!normalizedPrincipalId) {
+    return null;
+  }
+  try {
+    const users = await ctx.db.query("users").collect();
+    return users.find(
+      (user) => String(user.defaultPrincipalId ?? "") === normalizedPrincipalId
+    ) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function findAgentByPrincipalId(ctx, principalId) {
+  const normalizedPrincipalId = principalId.trim();
+  if (!normalizedPrincipalId) {
+    return null;
+  }
+  if (typeof ctx.runQuery === "function") {
+    try {
+      const bridgedAgent = await ctx.runQuery(
+        api.agents.getAgentByPrincipalId,
+        {
+          principalId: normalizedPrincipalId
+        }
+      );
+      if (bridgedAgent) {
+        return bridgedAgent;
+      }
+    } catch {
+    }
+  }
+  try {
+    const agents = await ctx.db.query("agents").collect();
+    return agents.find(
+      (agent) => String(agent.principalId ?? "") === normalizedPrincipalId
+    ) ?? null;
+  } catch {
+    return null;
+  }
+}
+function defaultResolvers() {
+  return {
+    async getProject(ctx, topicId) {
+      return await resolveTopicProjectOverlay(ctx, topicId, {
+        idMode: "legacy",
+        projectLikeOnly: false
+      });
+    },
+    async listTopics(ctx) {
+      return await listTopicProjectOverlays(ctx, { idMode: "legacy" });
+    },
+    async listTopicsByOwner(ctx, ownerId) {
+      const topics = await listTopicProjectOverlays(ctx, { idMode: "legacy" });
+      return topics.filter((topic) => topic.ownerId === ownerId);
+    },
+    async listTopicsByVisibility(ctx, visibility) {
+      const topics = await listTopicProjectOverlays(ctx, { idMode: "legacy" });
+      return topics.filter((topic) => topic.visibility === visibility);
+    },
+    async listProjectGrantsByProjectAndPrincipal(ctx, topicId, principalId) {
+      return await bridgeListProjectGrantsByTopicAndPrincipal(
+        ctx,
+        topicId,
+        principalId
+      );
+    },
+    async listProjectGrantsByProjectAndGroup(ctx, topicId, groupId) {
+      return await bridgeListProjectGrantsByTopicAndGroup(ctx, topicId, groupId);
+    },
+    async listProjectGrantsByPrincipalStatus(ctx, principalId, status) {
+      return await bridgeListProjectGrantsByPrincipalStatus(
+        ctx,
+        principalId,
+        status
+      );
+    },
+    async listProjectGrantsByGroupStatus(ctx, groupId, status) {
+      return await bridgeListProjectGrantsByGroupStatus(ctx, groupId, status);
+    },
+    async insertProjectGrant(ctx, value) {
+      return await bridgeInsertProjectGrant(ctx, value);
+    },
+    async getAgentByPrincipalId(ctx, principalId) {
+      return await findAgentByPrincipalId(ctx, principalId);
+    },
+    async getUserByClerkId(ctx, clerkId) {
+      return await findUserByClerkId(ctx, clerkId);
+    },
+    async getUserByPrincipalId(ctx, principalId) {
+      return await findUserByPrincipalId(ctx, principalId);
+    }
+  };
+}
+var resolverOverrides = {};
+function resolveAccessControlAppResolvers(_ctx) {
+  return {
+    ...defaultResolvers(),
+    ...resolverOverrides
+  };
+}
+
+// ../access-control/src/principalContext.ts
+function requireCanonicalResolvedUser(user, clerkId) {
+  const resolved = user;
+  if (!resolved) {
+    throw new Error(
+      `[AccessControl] Canonical user identity required for ${clerkId}. Sync users.upsertUser before user-bound access checks.`
+    );
+  }
+  const { mcRole, defaultTenantId, defaultWorkspaceId, defaultPrincipalId } = resolved;
+  if (mcRole !== "platform_admin" && mcRole !== "tenant_admin" && mcRole !== "workspace_admin" && mcRole !== "editor" && mcRole !== "viewer" && mcRole !== "auditor" && mcRole !== "service_agent") {
+    throw new Error(
+      `[AccessControl] Canonical MC role required for ${clerkId}. Re-sync Master Control identity before user-bound access checks.`
+    );
+  }
+  if (typeof defaultTenantId !== "string" || defaultTenantId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical home tenant required for ${clerkId}. Re-sync Master Control identity before user-bound access checks.`
+    );
+  }
+  if (typeof defaultWorkspaceId !== "string" || defaultWorkspaceId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical home workspace required for ${clerkId}. Re-sync Master Control identity before user-bound access checks.`
+    );
+  }
+  if (typeof defaultPrincipalId !== "string" || defaultPrincipalId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical federated principal required for ${clerkId}. Re-sync Master Control identity before user-bound access checks.`
+    );
+  }
+  return {
+    mcRole,
+    defaultTenantId: defaultTenantId.trim(),
+    defaultWorkspaceId: defaultWorkspaceId.trim(),
+    defaultPrincipalId: defaultPrincipalId.trim()
+  };
+}
+function isPrincipalIdInput(value) {
+  return value.startsWith("user:") || value.startsWith("group:") || value.startsWith("service:") || value.startsWith("agent:") || value.startsWith("external_viewer:");
+}
+async function resolveCanonicalUserRecord(ctx, actorId) {
+  const normalizedActorId = actorId.trim();
+  const clerkId = isPrincipalIdInput(normalizedActorId) && normalizedActorId.startsWith("user:") ? normalizedActorId.slice("user:".length) : normalizedActorId;
+  const resolvers = resolveAccessControlAppResolvers();
+  const resolvedByClerkId = await resolvers.getUserByClerkId(ctx, clerkId);
+  if (resolvedByClerkId) {
+    return {
+      resolvedUser: resolvedByClerkId,
+      clerkId,
+      contextClerkId: clerkId
+    };
+  }
+  const resolvedByPrincipalId = await resolvers.getUserByPrincipalId(
+    ctx,
+    normalizedActorId
+  );
+  return {
+    resolvedUser: resolvedByPrincipalId ?? null,
+    clerkId,
+    contextClerkId: normalizedActorId.startsWith("user:") && clerkId.length > 0 ? clerkId : normalizedActorId
+  };
+}
+function uniqRoles(roles) {
+  const roleSet = /* @__PURE__ */ new Set();
+  for (const role of roles) {
+    if (role === "platform_admin" || role === "tenant_admin" || role === "workspace_admin" || role === "editor" || role === "viewer" || role === "auditor" || role === "service_agent") {
+      roleSet.add(role);
+    }
+  }
+  return [...roleSet];
+}
+function normalizeGroupIds(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return [...new Set(
+    value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean)
+  )];
+}
+function requireServiceAgentUser(user, actorId) {
+  const canonicalUser = requireCanonicalResolvedUser(user, actorId);
+  if (canonicalUser.mcRole !== "service_agent") {
+    throw new Error(
+      `[AccessControl] Canonical service_agent identity required for ${actorId}. Sync users.upsertUser before agent-bound access checks.`
+    );
+  }
+  return canonicalUser;
+}
+function requireCanonicalResolvedAgent(agent, actorId) {
+  const resolved = agent;
+  if (!resolved) {
+    throw new Error(
+      `[AccessControl] Agent "${actorId}" not found in agents or users table.`
+    );
+  }
+  if (typeof resolved.principalId !== "string" || resolved.principalId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical agent principalId required for ${actorId}.`
+    );
+  }
+  if (typeof resolved.tenantId !== "string" || resolved.tenantId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical home tenant required for ${actorId}.`
+    );
+  }
+  if (typeof resolved.workspaceId !== "string" || resolved.workspaceId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical home workspace required for ${actorId}.`
+    );
+  }
+  return {
+    principalId: resolved.principalId.trim(),
+    tenantId: resolved.tenantId.trim(),
+    workspaceId: resolved.workspaceId.trim(),
+    roles: uniqRoles(Array.isArray(resolved.roles) ? resolved.roles : []) ?? ["service_agent"],
+    groupIds: normalizeGroupIds(resolved.groupIds)
+  };
+}
+async function resolvePrincipalContext(ctx, actorId) {
+  if (actorId.startsWith("agent:")) {
+    const resolvers = resolveAccessControlAppResolvers();
+    const resolvedAgent = await resolvers.getAgentByPrincipalId(ctx, actorId);
+    if (resolvedAgent) {
+      const agent = requireCanonicalResolvedAgent(
+        resolvedAgent,
+        actorId
+      );
+      return {
+        principalId: agent.principalId,
+        principalType: "service",
+        clerkId: actorId,
+        tenantId: agent.tenantId,
+        workspaceId: agent.workspaceId,
+        roles: agent.roles.length > 0 ? agent.roles : ["service_agent"],
+        groupIds: agent.groupIds,
+        isPlatformAdmin: false,
+        isTenantAdmin: false,
+        isWorkspaceAdmin: false,
+        isSystemFallback: false
+      };
+    }
+    const resolvedUser2 = await resolvers.getUserByClerkId(
+      ctx,
+      actorId
+    );
+    if (!resolvedUser2) {
+      throw new Error(
+        `[AccessControl] Agent "${actorId}" not found in agents or users table.`
+      );
+    }
+    const user2 = requireServiceAgentUser(
+      resolvedUser2,
+      actorId
+    );
+    console.warn(
+      `[AccessControl] Deprecated legacy service-agent fallback for ${actorId}; migrate this principal into identity.agents.`
+    );
+    return {
+      principalId: user2.defaultPrincipalId,
+      principalType: "service",
+      clerkId: actorId,
+      tenantId: user2.defaultTenantId,
+      workspaceId: user2.defaultWorkspaceId,
+      roles: ["service_agent"],
+      groupIds: normalizeGroupIds(resolvedUser2?.principalGroupIds),
+      isPlatformAdmin: false,
+      isTenantAdmin: false,
+      isWorkspaceAdmin: false,
+      isSystemFallback: false
+    };
+  }
+  const {
+    resolvedUser,
+    contextClerkId
+  } = await resolveCanonicalUserRecord(ctx, actorId);
+  const user = requireCanonicalResolvedUser(
+    resolvedUser,
+    contextClerkId
+  );
+  if (!user.defaultPrincipalId) {
+    throw new Error(
+      `[AccessControl] Canonical federated principal required for ${contextClerkId}. Re-sync Master Control identity before user-bound access checks.`
+    );
+  }
+  if (user.mcRole === "service_agent") {
+    return {
+      principalId: user.defaultPrincipalId,
+      principalType: "service",
+      clerkId: contextClerkId,
+      tenantId: user.defaultTenantId,
+      workspaceId: user.defaultWorkspaceId,
+      roles: ["service_agent"],
+      groupIds: normalizeGroupIds(resolvedUser?.principalGroupIds),
+      isPlatformAdmin: false,
+      isTenantAdmin: false,
+      isWorkspaceAdmin: false,
+      isSystemFallback: false
+    };
+  }
+  const principalId = user.defaultPrincipalId;
+  const effectiveRole = user.mcRole;
+  const roles = effectiveRole === "platform_admin" ? ["platform_admin", "tenant_admin"] : effectiveRole === "tenant_admin" ? ["tenant_admin"] : [effectiveRole];
+  const tenantId = user.defaultTenantId;
+  const workspaceId = user.defaultWorkspaceId;
+  const isPlatformAdmin = effectiveRole === "platform_admin";
+  return {
+    principalId,
+    principalType: "user",
+    clerkId: contextClerkId,
+    tenantId,
+    workspaceId,
+    roles: uniqRoles(roles),
+    groupIds: normalizeGroupIds(resolvedUser?.principalGroupIds),
+    isPlatformAdmin,
+    isTenantAdmin: isPlatformAdmin || effectiveRole === "tenant_admin",
+    isWorkspaceAdmin: isPlatformAdmin || effectiveRole === "tenant_admin" || effectiveRole === "workspace_admin",
+    isSystemFallback: false
+  };
+}
+
+// ../access-control/src/access.ts
+function isTopicInPrincipalTenant(topic, principalTenantId) {
+  if (!topic.tenantId) {
+    return false;
+  }
+  if (!principalTenantId) {
+    return false;
+  }
+  return String(topic.tenantId) === String(principalTenantId);
+}
+function isTopicInPrincipalWorkspace(topic, principalWorkspaceId) {
+  if (!topic.workspaceId) {
+    return false;
+  }
+  if (!principalWorkspaceId) {
+    return false;
+  }
+  return String(topic.workspaceId) === String(principalWorkspaceId);
+}
+function isLegacyUnscopedTopic(topic) {
+  return !topic.tenantId || !topic.workspaceId;
+}
+function isGrantScopeAlignedToTopic(topic, grant) {
+  if (topic.tenantId && grant.tenantId && String(topic.tenantId) !== String(grant.tenantId)) {
+    return false;
+  }
+  if (topic.workspaceId && grant.workspaceId && String(topic.workspaceId) !== String(grant.workspaceId)) {
+    return false;
+  }
+  return true;
+}
+function isGrantSourceAllowedForVisibility(visibility, source) {
+  if (source !== "external_share") {
+    return true;
+  }
+  return visibility === "external" || visibility === "public";
+}
+function isGrantActive(grant) {
+  if (grant.status !== "active") {
+    return false;
+  }
+  if (grant.expiresAt !== void 0 && grant.expiresAt <= Date.now()) {
+    return false;
+  }
+  return true;
+}
+async function hasPrincipalGrant(ctx, args) {
+  const grants = await resolveAccessControlAppResolvers().listProjectGrantsByProjectAndPrincipal(
+    ctx,
+    args.topic._id,
+    args.principalId
+  );
+  if (grants.some(
+    (grant) => isGrantActive(grant) && isGrantScopeAlignedToTopic(args.topic, grant) && isGrantSourceAllowedForVisibility(
+      args.topic.visibility,
+      grant.source
+    ) && (!args.principalIsExternal || args.topic.visibility === "public" || grant.source === "external_share")
+  )) {
+    return true;
+  }
+  return false;
+}
+async function hasGroupGrant(ctx, args) {
+  if (args.groupIds.length === 0) {
+    return false;
+  }
+  for (const groupId of args.groupIds) {
+    const grants = await resolveAccessControlAppResolvers().listProjectGrantsByProjectAndGroup(ctx, args.topic._id, groupId);
+    if (grants.some(
+      (grant) => isGrantActive(grant) && isGrantScopeAlignedToTopic(args.topic, grant) && isGrantSourceAllowedForVisibility(
+        args.topic.visibility,
+        grant.source
+      )
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+function isExternalPrincipal(_ctx, _args) {
+  return false;
+}
+async function evaluateTopicAccessDetailed(ctx, args) {
+  if (args.legacyUserId) {
+    return {
+      hasAccess: true,
+      isAdmin: false,
+      isOwner: false,
+      isShared: false,
+      hasGrant: true,
+      isFirmVisible: true,
+      isExternalVisible: false,
+      isPublicVisible: false,
+      isTenantScopeMatch: true,
+      isWorkspaceScopeMatch: true,
+      isPrincipalExternal: false
+    };
+  }
+  const topic = await resolveAccessControlAppResolvers().getProject(
+    ctx,
+    args.topicId
+  );
+  if (!topic) {
+    return {
+      hasAccess: false,
+      isAdmin: false,
+      isOwner: false,
+      isShared: false,
+      hasGrant: false,
+      isFirmVisible: false,
+      isExternalVisible: false,
+      isPublicVisible: false,
+      isTenantScopeMatch: false,
+      isWorkspaceScopeMatch: false,
+      isPrincipalExternal: false
+    };
+  }
+  const { principalContext, legacyUserId } = args;
+  const userIsAdmin = principalContext.isPlatformAdmin;
+  const isOwner = topic.ownerId === legacyUserId;
+  const isShared = (topic.sharedWith ?? []).includes(legacyUserId);
+  const principalIsExternal = await isExternalPrincipal(ctx, {
+    groupIds: principalContext.groupIds,
+    topicTenantId: topic.tenantId,
+    topicWorkspaceId: topic.workspaceId
+  });
+  const hasPrincipalGrantResult = await hasPrincipalGrant(ctx, {
+    topic,
+    principalId: principalContext.principalId,
+    principalIsExternal
+  });
+  const hasGroupGrantResult = await hasGroupGrant(ctx, {
+    topic,
+    groupIds: principalContext.groupIds
+  });
+  const hasGrant = isShared || hasPrincipalGrantResult || hasGroupGrantResult;
+  const legacyUnscoped = isLegacyUnscopedTopic(topic);
+  const tenantScopeMatch = isTopicInPrincipalTenant(
+    topic,
+    principalContext.tenantId
+  );
+  const workspaceScopeMatch = isTopicInPrincipalWorkspace(
+    topic,
+    principalContext.workspaceId
+  );
+  const isPublicVisible = topic.visibility === "public";
+  const isFirmVisible = topic.visibility === "firm" && !legacyUnscoped && tenantScopeMatch && workspaceScopeMatch && !principalIsExternal;
+  const hasScopedGrant = hasGrant && (legacyUnscoped || tenantScopeMatch && workspaceScopeMatch);
+  const isExternalVisible = topic.visibility === "external" && hasScopedGrant;
+  const hasAccess = userIsAdmin || isOwner || hasScopedGrant || isPublicVisible || isFirmVisible;
+  return {
+    hasAccess,
+    isAdmin: userIsAdmin,
+    isOwner,
+    isShared,
+    hasGrant,
+    isFirmVisible,
+    isExternalVisible,
+    isPublicVisible,
+    isTenantScopeMatch: tenantScopeMatch,
+    isWorkspaceScopeMatch: workspaceScopeMatch,
+    isPrincipalExternal: principalIsExternal
+  };
+}
+async function checkTopicAccessDetailed(ctx, topicId, userId) {
+  const principalContext = await resolvePrincipalContext(ctx, userId);
+  return evaluateTopicAccessDetailed(ctx, {
+    topicId,
+    legacyUserId: userId,
+    principalContext
+  });
+}
+async function checkTopicAccess(ctx, topicId, userId) {
+  const result = await checkTopicAccessDetailed(ctx, topicId, userId);
+  return result.hasAccess;
+}
+async function checkScopeAccess(ctx, scopeId, userId) {
+  try {
+    const topic = await ctx.db.get(scopeId);
+    if (topic && topic.name !== void 0 && topic.type !== void 0) {
+      return true;
+    }
+  } catch {
+  }
+  try {
+    return await checkTopicAccess(ctx, scopeId, userId);
+  } catch {
+    return false;
+  }
+}
+async function requireTopicAccess(ctx, topicId, userId) {
+  const hasAccess = await checkTopicAccess(ctx, topicId, userId);
+  if (!hasAccess) {
+    throw new Error(
+      "Access denied: You don't have permission to access this topic"
+    );
+  }
+}
+var requireProjectAccess = requireTopicAccess;
+var permissiveReturn = v.optional(v.any());
+var looseJsonObject = v.record(v.string(), v.any());
+var looseJsonArray = v.array(v.any());
+v.union(
+  v.string(),
+  v.number(),
+  v.boolean(),
+  v.null(),
+  looseJsonObject,
+  looseJsonArray
+);
+var api2 = anyApi;
+componentsGeneric();
+var internal = anyApi;
+var internalMutation = internalMutationGeneric;
+var mutation = mutationGeneric;
+var query = queryGeneric;
+
+// src/graphTypes.ts
+var EDGE_TYPE_TO_REL = {
+  // === THE SIX CANONICAL EPISTEMIC EDGE TYPES ===
+  supports: "SUPPORTS",
+  // L3↔L3: belief bears on belief (weight -1 to +1)
+  informs: "INFORMS",
+  // L2→L3: evidence bears on belief
+  depends_on: "DEPENDS_ON",
+  // L3→L3, Q→Q: structural gate
+  derived_from: "DERIVED_FROM",
+  // Any→Any: provenance chain (fork, synthesis, extraction, answer)
+  contains: "CONTAINS",
+  // Any→Any: hierarchy, scoping, membership
+  tests: "TESTS",
+  // Q→L3: question interrogates belief
+  // === L4 DECISION EDGES (derived_from with derivationType=decision) ===
+  // Kept as separate Neo4j relationship types for backward compat with L4 queries.
+  // New code should use derived_from + metadata.
+  based_on_belief: "BASED_ON_BELIEF",
+  based_on_question: "BASED_ON_QUESTION",
+  blocked_by_contradiction: "BLOCKED_BY_CONTRADICTION",
+  informed_by_theme: "INFORMED_BY_THEME",
+  // === ONTOLOGICAL EDGES (tenant-extensible, managed by ontology system) ===
+  works_at: "WORKS_AT",
+  invested_in: "INVESTED_IN",
+  competes_with: "COMPETES_WITH",
+  participates_in: "PARTICIPATES_IN",
+  founded_by: "FOUNDED_BY",
+  evaluates: "EVALUATES",
+  performs: "PERFORMS",
+  function_in: "FUNCTION_IN",
+  impacts: "IMPACTS",
+  raised_from: "RAISED_FROM",
+  mentioned_in: "MENTIONED_IN",
+  perspective_on: "PERSPECTIVE_ON",
+  about_entity: "ABOUT_ENTITY",
+  entity_referenced_in: "ENTITY_REFERENCED_IN"
+};
+function getNodeLayer(nodeType) {
+  const L4_TYPES = ["decision"];
+  const L3_TYPES = ["belief", "question", "theme", "deal"];
+  const L2_TYPES = ["claim", "evidence", "synthesis", "answer"];
+  const L1_TYPES = ["atomic_fact", "excerpt", "source"];
+  const ONTOLOGICAL_TYPES = [
+    "company",
+    "person",
+    "investor",
+    "function",
+    "value_chain"
+  ];
+  const ORGANIZATIONAL_TYPES = ["topic"];
+  if (L4_TYPES.includes(nodeType)) {
+    return "L4";
+  }
+  if (L3_TYPES.includes(nodeType)) {
+    return "L3";
+  }
+  if (L2_TYPES.includes(nodeType)) {
+    return "L2";
+  }
+  if (L1_TYPES.includes(nodeType)) {
+    return "L1";
+  }
+  if (ONTOLOGICAL_TYPES.includes(nodeType)) {
+    return "ontological";
+  }
+  if (ORGANIZATIONAL_TYPES.includes(nodeType)) {
+    return "organizational";
+  }
+  console.warn(`[GraphTypes] Unknown nodeType "${nodeType}", defaulting to L2`);
+  return "L2";
+}
+var CANONICAL_EPISTEMIC_TYPES = /* @__PURE__ */ new Set([
+  "supports",
+  "informs",
+  "depends_on",
+  "derived_from",
+  "contains",
+  "tests"
+]);
+function isDeprecatedEdgeType(edgeType) {
+  if (CANONICAL_EPISTEMIC_TYPES.has(edgeType)) return false;
+  if (edgeType in EDGE_TYPE_TO_REL) return false;
+  return true;
+}
+
+// src/edgeValidation.ts
+function getLayerDepth(layer) {
+  switch (layer) {
+    case "L4":
+      return 4;
+    case "L3":
+      return 3;
+    case "L2":
+      return 2;
+    case "L1":
+      return 1;
+    case "ontological":
+      return 0;
+    default:
+      return -1;
+  }
+}
+function isValidLayerConnection(fromLayer, toLayer) {
+  if (fromLayer === toLayer) {
+    return true;
+  }
+  if (fromLayer === "ontological" && toLayer === "ontological") {
+    return true;
+  }
+  if (fromLayer === "ontological" && (toLayer === "L3" || toLayer === "L2" || toLayer === "L1")) {
+    return true;
+  }
+  if ((fromLayer === "L3" || fromLayer === "L2" || fromLayer === "L1") && toLayer === "ontological") {
+    return true;
+  }
+  if (fromLayer === "L2" && toLayer === "L1") {
+    return true;
+  }
+  if (fromLayer === "L2" && toLayer === "L3") {
+    return true;
+  }
+  if (fromLayer === "L3" && toLayer === "L2") {
+    return true;
+  }
+  if (fromLayer === "L3" && toLayer === "L4") {
+    return true;
+  }
+  if (fromLayer === "L4" && toLayer === "L3") {
+    return true;
+  }
+  if (fromLayer === "L3" && toLayer === "organizational") {
+    return true;
+  }
+  if (fromLayer === "organizational" && toLayer === "L3") {
+    return true;
+  }
+  const fromDepth = getLayerDepth(fromLayer);
+  const toDepth = getLayerDepth(toLayer);
+  if (Math.abs(fromDepth - toDepth) > 1) {
+    return false;
+  }
+  return true;
+}
+function shouldContinueTraversal(currentLayer, targetLayer, options) {
+  const currentDepth = getLayerDepth(currentLayer);
+  const targetDepth = getLayerDepth(targetLayer);
+  if (options.minLayer !== void 0 && targetDepth < options.minLayer) {
+    return false;
+  }
+  if (options.maxLayer !== void 0 && targetDepth > options.maxLayer) {
+    return false;
+  }
+  switch (options.mode) {
+    case "anchor_down":
+      return targetDepth <= currentDepth;
+    case "anchor_up":
+      return targetDepth >= currentDepth;
+    case "same_layer":
+      return targetDepth === currentDepth;
+    case "decision_trace":
+      return currentDepth === 4 ? targetDepth === 3 : targetDepth === currentDepth;
+    default:
+      return true;
+  }
+}
+function getDefaultMinLayer(mode) {
+  switch (mode) {
+    case "anchor_down":
+      return 1;
+    case "anchor_up":
+      return 2;
+    case "same_layer":
+      return 1;
+    case "decision_trace":
+      return 3;
+    default:
+      return 1;
+  }
+}
+var EDGE_LAYER_RULES = {
+  // === 6 Canonical Epistemic Types ===
+  supports: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief bears on Belief (weight: +1 supports, -1 contradicts)"
+  },
+  informs: {
+    from: ["L2"],
+    to: ["L3"],
+    description: "Evidence -> Belief (L2 -> L3)"
+  },
+  depends_on: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief B requires Belief A (structural gate)"
+  },
+  derived_from: {
+    from: ["L2", "L3", "L4"],
+    to: ["L1", "L2", "L3"],
+    description: "A was produced from B (provenance chain)"
+  },
+  contains: {
+    from: ["L3", "L4", "ontological"],
+    to: ["L2", "L3", "ontological"],
+    description: "A scopes/aggregates B (hierarchy)"
+  },
+  tests: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Question -> Belief (L3 -> L3)"
+  },
+  // === Structural / Lifecycle ===
+  supersedes: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "NewNode -> OldNode (fork lineage)"
+  },
+  responds_to: {
+    from: ["L2", "L3"],
+    to: ["L3"],
+    description: "Answer -> Question (L2/L3 -> L3)"
+  },
+  belongs_to: {
+    from: ["L2", "L3", "ontological"],
+    to: ["L3"],
+    description: "Membership (migrating to contains)"
+  },
+  relates_to_thesis: {
+    from: ["L3"],
+    to: ["L3"],
+    description: "Belief -> Theme (L3 -> L3)"
+  },
+  // === Ontological (entity-entity or entity-epistemic bridge) ===
+  works_at: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Person -> Company"
+  },
+  invested_in: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Investor -> Company"
+  },
+  competes_with: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Company -> Company"
+  },
+  participates_in: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Company -> ValueChain"
+  },
+  founded_by: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Company -> Person"
+  },
+  evaluates: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Deal -> Company"
+  },
+  performs: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Company -> Function"
+  },
+  function_in: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Function -> ValueChain"
+  },
+  impacts: {
+    from: ["ontological", "L3"],
+    to: ["ontological"],
+    description: "Theme/Entity -> ValueChain"
+  },
+  raised_from: {
+    from: ["ontological"],
+    to: ["ontological"],
+    description: "Company -> Investor"
+  },
+  mentioned_in: {
+    from: ["ontological"],
+    to: ["L1", "L2"],
+    description: "Entity -> Source/Evidence"
+  },
+  perspective_on: {
+    from: ["ontological"],
+    to: ["L3"],
+    description: "Person -> Belief/Theme"
+  },
+  plays_theme: {
+    from: ["ontological"],
+    to: ["L3"],
+    description: "Deal -> Theme"
+  }
+};
+function validateEdgeLayers(edgeType, fromLayer, toLayer) {
+  const rules = EDGE_LAYER_RULES[edgeType];
+  if (!rules) {
+    console.warn(
+      `[EdgeValidation] Unknown edge type: ${edgeType}, allowing by default`
+    );
+    return { valid: true };
+  }
+  if (edgeType === "supersedes") {
+    if (fromLayer !== toLayer) {
+      return {
+        valid: false,
+        reason: `${edgeType} edges must be between nodes of the same layer. Got ${fromLayer} -> ${toLayer}`
+      };
+    }
+    return { valid: true };
+  }
+  if (!rules.from.includes(fromLayer)) {
+    return {
+      valid: false,
+      reason: `Edge type '${edgeType}' does not allow source layer ${fromLayer}. Allowed: ${rules.from.join(", ")}`
+    };
+  }
+  if (!rules.to.includes(toLayer)) {
+    return {
+      valid: false,
+      reason: `Edge type '${edgeType}' does not allow target layer ${toLayer}. Allowed: ${rules.to.join(", ")}`
+    };
+  }
+  if (!isValidLayerConnection(fromLayer, toLayer)) {
+    return {
+      valid: false,
+      reason: `Layer transition ${fromLayer} -> ${toLayer} is not permitted`
+    };
+  }
+  return { valid: true };
+}
+
+// src/topicProjectOverlay.ts
+var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
+function readNonEmptyString2(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function readStringArray2(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => readNonEmptyString2(entry)).filter((entry) => Boolean(entry));
+}
+function readMetadata2(topic) {
+  return topic.metadata && typeof topic.metadata === "object" ? topic.metadata : {};
+}
+function readLegacyProjectId2(value) {
+  if (!value) {
+    return;
+  }
+  return readNonEmptyString2(value[LEGACY_SCOPE_FIELD2]);
+}
+function coerceVisibility2(value) {
+  return value === "private" || value === "team" || value === "firm" || value === "external" || value === "public" ? value : void 0;
+}
+function coerceStatus2(value) {
+  return value === "active" || value === "archived" || value === "watching" ? value : void 0;
+}
+function mapProjectType2(topic, metadata) {
+  const explicit = readNonEmptyString2(metadata.projectType);
+  if (explicit) {
+    return explicit;
+  }
+  if (topic.type === "theme") {
+    return "thematic";
+  }
+  return readNonEmptyString2(topic.type) || "general";
+}
+function isProjectLikeTopic2(topic) {
+  const metadata = readMetadata2(topic);
+  return topic.type === "theme" || topic.type === "thematic" || topic.type === "deal" || topic.type === "monitoring" || readLegacyProjectId2(topic) !== void 0 || readNonEmptyString2(metadata.projectType) !== void 0;
+}
+function isMissingLucernChildComponentError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes(
+    'Child component ComponentName(Identifier("lucern")) not found'
+  ) || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
+}
+async function resolveTopicDoc2(ctx, scopeId) {
+  if (ctx?.db && typeof ctx.db.get === "function") {
+    try {
+      const directTopic = await ctx.db.get(scopeId);
+      if (directTopic) {
+        return directTopic;
+      }
+    } catch {
+    }
+  }
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    const topic = await ctx.runQuery(api2.topics.get, {
+      id: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch {
+  }
+  try {
+    const topic = await ctx.runQuery(api2.topics.getByLegacyScopeId, {
+      projectId: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch {
+  }
+  return null;
+}
+function materializeTopicProjectOverlay2(topic, idMode = "legacy") {
+  const metadata = readMetadata2(topic);
+  const topicId = String(topic._id);
+  const legacyProjectId = readLegacyProjectId2(topic) || readLegacyProjectId2(metadata) || readNonEmptyString2(metadata.legacyProjectId);
+  const storageProjectId = legacyProjectId || topicId;
+  const outwardId = idMode === "topic" ? topicId : storageProjectId;
+  const visibility = coerceVisibility2(topic.visibility) || coerceVisibility2(metadata.visibility) || "private";
+  const status = coerceStatus2(topic.status) || coerceStatus2(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: readNonEmptyString2(topic.name) || "Untitled Theme",
+    type: mapProjectType2(topic, metadata),
+    description: readNonEmptyString2(topic.description),
+    ownerId: readNonEmptyString2(metadata.ownerId) || readNonEmptyString2(topic.createdBy) || "system",
+    sharedWith: readStringArray2(metadata.sharedWith),
+    visibility,
+    tenantId: readNonEmptyString2(topic.tenantId) || readNonEmptyString2(metadata.tenantId),
+    workspaceId: readNonEmptyString2(topic.workspaceId) || readNonEmptyString2(metadata.workspaceId),
+    status,
+    tags: readStringArray2(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 resolveTopicProjectOverlay2(ctx, scopeId, options = {}) {
+  const topic = await resolveTopicDoc2(ctx, scopeId);
+  if (!topic) {
+    return null;
+  }
+  if (options.projectLikeOnly !== false && !isProjectLikeTopic2(topic)) {
+    return null;
+  }
+  return materializeTopicProjectOverlay2(topic, options.idMode);
+}
+async function listTopicProjectOverlays2(ctx, options = {}) {
+  let allTopics = [];
+  if (ctx?.db?.query && typeof ctx.db.query === "function") {
+    try {
+      allTopics = await ctx.db.query("topics").collect();
+    } catch {
+      allTopics = [];
+    }
+  }
+  if (allTopics.length === 0 && typeof ctx.runQuery === "function") {
+    allTopics = (await ctx.runQuery(api2.topics.list, {}) ?? []) || [];
+  }
+  return allTopics.filter(
+    (topic) => options.projectLikeOnly === false || isProjectLikeTopic2(topic)
+  ).map((topic) => materializeTopicProjectOverlay2(topic, options.idMode));
+}
+async function patchTopicProjectOverlay(ctx, scopeId, value) {
+  const topic = await resolveTopicDoc2(ctx, scopeId);
+  if (!topic) {
+    return null;
+  }
+  const nextMetadata = { ...readMetadata2(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 = coerceStatus2(rawValue);
+        if (status) {
+          patch.status = status;
+          topicUpdateArgs.status = status;
+        }
+        break;
+      }
+      case "visibility": {
+        const visibility = coerceVisibility2(rawValue);
+        if (visibility) {
+          patch.visibility = visibility;
+          topicUpdateArgs.visibility = visibility;
+        }
+        break;
+      }
+      case "type": {
+        const projectType = readNonEmptyString2(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(api2.topics.update, topicUpdateArgs);
+    } catch (error) {
+      if (!isMissingLucernChildComponentError(error) || !ctx?.db || typeof ctx.db.patch !== "function") {
+        throw error;
+      }
+      await ctx.db.patch(String(topic._id), patch);
+    }
+  } else if (ctx?.db && typeof ctx.db.patch === "function") {
+    await ctx.db.patch(String(topic._id), patch);
+  } else {
+    throw new Error(
+      "Cannot patch topic without component adapter (ctx.runMutation unavailable)"
+    );
+  }
+  return materializeTopicProjectOverlay2(
+    {
+      ...topic,
+      ...patch,
+      metadata: nextMetadata
+    }
+  );
+}
+
+// src/resolvers.ts
+function isMissingLucernChildComponentError2(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes('Child component ComponentName(Identifier("lucern")) not found') || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
+}
+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: error instanceof Error ? error.message : error
+    });
+  }
+}
+function defaultResolvers2() {
+  return {
+    async getProject(ctx, projectId) {
+      return await resolveTopicProjectOverlay2(ctx, projectId, {
+        idMode: "legacy",
+        projectLikeOnly: false
+      });
+    },
+    async patchProject(ctx, projectId, value) {
+      await patchProjectWithTolerance(ctx, projectId, value);
+    },
+    async listTopics(ctx) {
+      return await listTopicProjectOverlays2(ctx, {
+        idMode: "legacy"
+      });
+    },
+    async getFinalArtifact(ctx, artifactId) {
+      return await ctx.db.get(artifactId);
+    }
+  };
+}
+var resolverOverrides2 = {};
+function resolveGraphPrimitivesAppResolvers(_ctx) {
+  return {
+    ...defaultResolvers2(),
+    ...resolverOverrides2
+  };
+}
+var LEGACY_SCOPE_FIELD3 = "graphScopeProjectId";
+function asMappedProjectId(topic) {
+  if (!topic) {
+    return;
+  }
+  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD3]);
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
+  }
+  const metadata = topic.metadata || {};
+  const candidate = metadata[LEGACY_SCOPE_FIELD3] || 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_FIELD3, scopeId)
+    ).collect();
+  } catch {
+    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(api2.topics.get, {
+      id: topicId
+    }) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api2.topics.getByLegacyScopeId, {
+      projectId: legacyScopeId
+    }) ?? null;
+  } catch {
+    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 {
+    }
+    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 {
+    }
+    if (directTopic) {
+      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
+      const mapped = asMappedProjectId(directTopic);
+      return {
+        topicId: directTopic._id,
+        projectId: mapped ?? args.projectId,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "topic_inferred"
+      };
+    }
+    directTopic = await tryResolveHostTopicByLegacyScope(ctx, args.projectId);
+    if (directTopic) {
+      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
+      const mapped = asMappedProjectId(directTopic);
+      return {
+        topicId: directTopic._id,
+        projectId: mapped ?? args.projectId,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "topic_inferred"
+      };
+    }
+    const topics = await findTopicsByScopeAlias(ctx, args.projectId);
+    const primary = pickPrimaryTopic(topics);
+    if (primary) {
+      const inherited = await resolveInheritedWorkspaceScope(ctx, primary);
+      return {
+        topicId: primary._id,
+        projectId: args.projectId,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "project_mapped_topic"
+      };
+    }
+    throw new Error(
+      `Legacy project scope ${String(args.projectId)} has no mapped topic.`
+    );
+  }
+  throw new Error(
+    "Missing scope: provide topicId (preferred) or legacy projectId alias."
+  );
+}
+var optionalScopeArgs = {
+  projectId: v.optional(v.string()),
+  topicId: v.optional(v.string())
+};
+
+// 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)
+);
+var get = query({
+  args: { edgeId: v.id("epistemicEdges") },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.edgeId);
+  }
+});
+var getByGlobalId = query({
+  args: { globalId: v.string() },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    return await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
+  }
+});
+var getFromNode = query({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    edgeType: v.optional(edgeTypeValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const { edgeType } = args;
+    if (edgeType) {
+      return await ctx.db.query("epistemicEdges").withIndex(
+        "by_from_type",
+        (q) => q.eq("fromNodeId", args.fromNodeId).eq("edgeType", edgeType)
+      ).collect();
+    }
+    return await ctx.db.query("epistemicEdges").withIndex("by_from", (q) => q.eq("fromNodeId", args.fromNodeId)).collect();
+  }
+});
+var getToNode = query({
+  args: {
+    toNodeId: v.id("epistemicNodes"),
+    edgeType: v.optional(edgeTypeValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const { edgeType } = args;
+    if (edgeType) {
+      return await ctx.db.query("epistemicEdges").withIndex(
+        "by_to_type",
+        (q) => q.eq("toNodeId", args.toNodeId).eq("edgeType", edgeType)
+      ).collect();
+    }
+    return await ctx.db.query("epistemicEdges").withIndex("by_to", (q) => q.eq("toNodeId", args.toNodeId)).collect();
+  }
+});
+var getBySourceNode = query({
+  args: {
+    sourceNodeId: v.string(),
+    edgeType: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const isConvexId = args.sourceNodeId.length === 32 || args.sourceNodeId.includes("epistemicNodes");
+    if (isConvexId) {
+      const query2 = args.edgeType ? ctx.db.query("epistemicEdges").withIndex(
+        "by_from_type",
+        (q) => q.eq("fromNodeId", args.sourceNodeId).eq("edgeType", args.edgeType)
+      ) : ctx.db.query("epistemicEdges").withIndex(
+        "by_from",
+        (q) => q.eq("fromNodeId", args.sourceNodeId)
+      );
+      return await query2.collect();
+    }
+    const byGlobalId = await ctx.db.query("epistemicEdges").withIndex(
+      "by_source_global_id",
+      (q) => q.eq("sourceGlobalId", args.sourceNodeId)
+    ).collect();
+    if (args.edgeType) {
+      return byGlobalId.filter((edge) => edge.edgeType === args.edgeType);
+    }
+    return byGlobalId;
+  }
+});
+var getByTargetNode = query({
+  args: {
+    targetNodeId: v.string(),
+    edgeType: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const isConvexId = args.targetNodeId.length === 32 || args.targetNodeId.includes("epistemicNodes");
+    if (isConvexId) {
+      const query2 = args.edgeType ? ctx.db.query("epistemicEdges").withIndex(
+        "by_to_type",
+        (q) => q.eq("toNodeId", args.targetNodeId).eq("edgeType", args.edgeType)
+      ) : ctx.db.query("epistemicEdges").withIndex(
+        "by_to",
+        (q) => q.eq("toNodeId", args.targetNodeId)
+      );
+      return await query2.collect();
+    }
+    const byGlobalId = await ctx.db.query("epistemicEdges").withIndex(
+      "by_target_global_id",
+      (q) => q.eq("targetGlobalId", args.targetNodeId)
+    ).collect();
+    if (args.edgeType) {
+      return byGlobalId.filter((edge) => edge.edgeType === args.edgeType);
+    }
+    return byGlobalId;
+  }
+});
+var getBetween = query({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    toNodeId: v.id("epistemicNodes"),
+    edgeType: v.optional(edgeTypeValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_from_to",
+      (q) => q.eq("fromNodeId", args.fromNodeId).eq("toNodeId", args.toNodeId)
+    ).collect();
+    if (args.edgeType) {
+      return edges.filter((e) => e.edgeType === args.edgeType);
+    }
+    return edges;
+  }
+});
+var getByNodes = query({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    toNodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    return await ctx.db.query("epistemicEdges").withIndex(
+      "by_from_to",
+      (q) => q.eq("fromNodeId", args.fromNodeId).eq("toNodeId", args.toNodeId)
+    ).first();
+  }
+});
+var getByProjectAndType = query({
+  args: {
+    ...optionalScopeArgs,
+    edgeType: edgeTypeValidator
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    if (!args.projectId && !args.topicId) {
+      return [];
+    }
+    let scope;
+    try {
+      scope = await resolveTopicProjectScope(ctx, {
+        projectId: args.projectId,
+        topicId: args.topicId
+      });
+    } catch {
+      return [];
+    }
+    const projectEdges = await collectScopedEdges(ctx, scope, 5e3);
+    return projectEdges.filter(
+      (e) => e.edgeType === args.edgeType && edgeMatchesWorkspaceReasoningScope(e, scope)
+    ).slice(0, 5e3);
+  }
+});
+var getByProject = query({
+  args: {
+    ...optionalScopeArgs,
+    userId: v.optional(v.string()),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    if (!args.projectId && !args.topicId) {
+      return [];
+    }
+    let scope;
+    try {
+      scope = await resolveTopicProjectScope(ctx, {
+        projectId: args.projectId,
+        topicId: args.topicId
+      });
+    } catch {
+      return [];
+    }
+    if (args.userId) {
+      const hasAccess = await checkScopeAccess(
+        ctx,
+        String(scope.topicId ?? scope.projectId),
+        args.userId
+      );
+      if (!hasAccess) {
+        return [];
+      }
+    }
+    const pageSize = Math.max(1, Math.min(Math.floor(args.limit ?? 500), 2e3));
+    const edges = await collectScopedEdges(ctx, scope, Math.min(pageSize * 3, 6e3));
+    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;
+    }
+    seen.add(key);
+    deduped.push(edge);
+  }
+  return deduped;
+}
+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)
+    );
+  }
+  return dedupeWorkspaceEdges((await Promise.all(queries)).flat());
+}
+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 create = mutation({
+  args: {
+    globalId: v.string(),
+    fromNodeId: v.id("epistemicNodes"),
+    toNodeId: v.id("epistemicNodes"),
+    edgeType: edgeTypeValidator,
+    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,
+  handler: async (ctx, args) => {
+    const fromNode = await ctx.db.get(args.fromNodeId);
+    const toNode = await ctx.db.get(args.toNodeId);
+    if (!fromNode || !toNode) {
+      throw new Error("One or both nodes not found");
+    }
+    const resolvedScope = args.topicId || args.projectId ? await resolveTopicProjectScope(ctx, {
+      topicId: args.topicId,
+      projectId: args.projectId
+    }) : void 0;
+    const resolvedProjectId = resolvedScope?.projectId ?? args.projectId;
+    if (resolvedProjectId) {
+      await requireProjectAccess(ctx, resolvedProjectId, args.createdBy);
+    }
+    const fromLayer = fromNode.epistemicLayer || getNodeLayer(fromNode.nodeType);
+    const toLayer = toNode.epistemicLayer || getNodeLayer(toNode.nodeType);
+    if (!args.skipLayerValidation) {
+      const validation = validateEdgeLayers(args.edgeType, fromLayer, toLayer);
+      if (!validation.valid) {
+        throw new Error(
+          `[EdgeValidation] Invalid edge: ${validation.reason}. Attempted: ${args.edgeType} from ${fromNode.nodeType}(${fromLayer}) \u2192 ${toNode.nodeType}(${toLayer})`
+        );
+      }
+    }
+    if (isDeprecatedEdgeType(args.edgeType)) {
+      throw new Error(
+        `FORBIDDEN: Edge type '${args.edgeType}' has been removed from StackOS schema.`
+      );
+    }
+    const existing = await ctx.db.query("epistemicEdges").withIndex(
+      "by_from_to",
+      (q) => q.eq("fromNodeId", args.fromNodeId).eq("toNodeId", args.toNodeId)
+    ).collect();
+    const duplicateEdge = existing.find((e) => e.edgeType === args.edgeType);
+    if (duplicateEdge) {
+      return { edgeId: duplicateEdge._id, isDuplicate: true };
+    }
+    await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+      globalId: args.globalId,
+      fromGlobalId: fromNode.globalId,
+      toGlobalId: toNode.globalId,
+      edgeType: args.edgeType,
+      weight: args.weight,
+      confidence: args.confidence,
+      context: args.context,
+      derivationType: args.derivationType,
+      createdBy: args.createdBy,
+      topicId: resolvedProjectId ? String(resolvedProjectId) : void 0,
+      fromNodeType: fromNode.nodeType,
+      toNodeType: toNode.nodeType,
+      fromLayer,
+      toLayer
+    });
+    const auditProjectId = resolvedProjectId || fromNode.projectId;
+    if (auditProjectId) {
+      await ctx.db.insert("epistemicAudit", {
+        entityType: "edge",
+        entityId: args.globalId,
+        changeType: "edge_added",
+        changedAt: Date.now(),
+        changedBy: args.createdBy,
+        isAgent: false,
+        newState: {
+          edgeType: args.edgeType,
+          fromNodeId: String(args.fromNodeId),
+          toNodeId: String(args.toNodeId),
+          weight: args.weight
+        },
+        projectId: auditProjectId
+      });
+      await resolveGraphPrimitivesAppResolvers().patchProject(
+        ctx,
+        auditProjectId,
+        {
+          lastActivityAt: Date.now()
+        }
+      );
+    }
+    return { edgeGlobalId: args.globalId, isDuplicate: false };
+  }
+});
+var update = mutation({
+  args: {
+    edgeId: v.id("epistemicEdges"),
+    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()),
+    implicit: v.optional(v.boolean()),
+    conditionalA: v.optional(subjectiveOpinionValidator),
+    conditionalNotA: v.optional(subjectiveOpinionValidator),
+    containment: v.optional(v.string()),
+    interrogation: v.optional(v.string()),
+    reasoningMethod: v.optional(v.string()),
+    analogyBasis: v.optional(v.string()),
+    disanalogies: v.optional(v.array(v.string())),
+    analogyStrength: v.optional(v.number()),
+    causal: v.optional(v.boolean()),
+    predictionFulfilled: v.optional(v.boolean()),
+    predictionFulfilledAt: v.optional(v.number()),
+    predictionFulfilledBy: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const { edgeId, userId, ...updates } = args;
+    const edge = await ctx.db.get(edgeId);
+    if (!edge) {
+      throw new Error("Edge not found");
+    }
+    if (edge.projectId && userId) {
+      await requireProjectAccess(ctx, edge.projectId, userId);
+    }
+    const cleanUpdates = {};
+    for (const [key, value] of Object.entries(updates)) {
+      if (value !== void 0) {
+        cleanUpdates[key] = value;
+      }
+    }
+    await ctx.db.patch(edgeId, cleanUpdates);
+    if (edge.projectId) {
+      await ctx.db.insert("epistemicAudit", {
+        entityType: "edge",
+        entityId: edge.globalId,
+        changeType: "updated",
+        changedAt: Date.now(),
+        changedBy: userId || edge.createdBy,
+        isAgent: false,
+        previousState: {
+          weight: edge.weight,
+          confidence: edge.confidence,
+          context: edge.context
+        },
+        newState: cleanUpdates,
+        projectId: edge.projectId
+      });
+    }
+    return { success: true };
+  }
+});
+var remove = mutation({
+  args: {
+    edgeId: v.id("epistemicEdges"),
+    userId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edge = await ctx.db.get(args.edgeId);
+    if (!edge) {
+      return { success: false, error: "Edge not found" };
+    }
+    if (edge.projectId && args.userId) {
+      await requireProjectAccess(ctx, edge.projectId, args.userId);
+    }
+    if (edge.projectId) {
+      await ctx.db.insert("epistemicAudit", {
+        entityType: "edge",
+        entityId: edge.globalId,
+        changeType: "edge_removed",
+        changedAt: Date.now(),
+        changedBy: args.userId || edge.createdBy,
+        isAgent: false,
+        previousState: {
+          edgeType: edge.edgeType,
+          fromNodeId: String(edge.fromNodeId),
+          toNodeId: edge.toNodeId ? String(edge.toNodeId) : void 0,
+          weight: edge.weight
+        },
+        projectId: edge.projectId
+      });
+    }
+    if (edge.projectId) {
+      await resolveGraphPrimitivesAppResolvers().patchProject(
+        ctx,
+        edge.projectId,
+        {
+          lastActivityAt: Date.now()
+        }
+      );
+    }
+    await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+      globalId: edge.globalId
+    });
+    await ctx.db.delete(args.edgeId);
+    return { success: true };
+  }
+});
+var removeBetween = mutation({
+  args: {
+    fromNodeId: v.id("epistemicNodes"),
+    toNodeId: v.id("epistemicNodes"),
+    edgeType: v.optional(edgeTypeValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_from_to",
+      (q) => q.eq("fromNodeId", args.fromNodeId).eq("toNodeId", args.toNodeId)
+    ).collect();
+    let deleted = 0;
+    for (const edge of edges) {
+      if (!args.edgeType || edge.edgeType === args.edgeType) {
+        await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+          globalId: edge.globalId
+        });
+        await ctx.db.delete(edge._id);
+        deleted++;
+      }
+    }
+    return { deleted };
+  }
+});
+var batchCreate = mutation({
+  args: {
+    edges: v.array(
+      v.object({
+        globalId: v.string(),
+        fromNodeId: v.id("epistemicNodes"),
+        toNodeId: v.id("epistemicNodes"),
+        edgeType: edgeTypeValidator,
+        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,
+  handler: async (ctx, args) => {
+    const results = [];
+    const errors = [];
+    for (const edge of args.edges) {
+      const fromNode = await ctx.db.get(edge.fromNodeId);
+      const toNode = await ctx.db.get(edge.toNodeId);
+      if (!fromNode || !toNode) {
+        errors.push({
+          globalId: edge.globalId,
+          error: "One or both nodes not found"
+        });
+        continue;
+      }
+      const fromLayer = fromNode.epistemicLayer || getNodeLayer(fromNode.nodeType);
+      const toLayer = toNode.epistemicLayer || getNodeLayer(toNode.nodeType);
+      if (!args.skipLayerValidation) {
+        const validation = validateEdgeLayers(
+          edge.edgeType,
+          fromLayer,
+          toLayer
+        );
+        if (!validation.valid) {
+          errors.push({
+            globalId: edge.globalId,
+            error: validation.reason || "Invalid layer combination"
+          });
+          continue;
+        }
+      }
+      if (isDeprecatedEdgeType(edge.edgeType)) {
+        errors.push({
+          globalId: edge.globalId,
+          error: `FORBIDDEN: Edge type '${edge.edgeType}' has been removed from StackOS schema.`
+        });
+        continue;
+      }
+      await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+        globalId: edge.globalId,
+        fromGlobalId: fromNode.globalId,
+        toGlobalId: toNode.globalId,
+        edgeType: edge.edgeType,
+        weight: edge.weight,
+        confidence: edge.confidence,
+        context: edge.context,
+        derivationType: edge.derivationType,
+        createdBy: edge.createdBy,
+        topicId: edge.projectId ? String(edge.projectId) : void 0,
+        fromNodeType: fromNode.nodeType,
+        toNodeType: toNode.nodeType,
+        fromLayer,
+        toLayer
+      });
+      results.push({ globalId: edge.globalId, edgeGlobalId: edge.globalId });
+    }
+    const projectIds = new Set(
+      args.edges.flatMap(
+        (edge) => typeof edge.projectId === "string" ? [edge.projectId] : []
+      )
+    );
+    for (const pid of projectIds) {
+      if (pid) {
+        await resolveGraphPrimitivesAppResolvers().patchProject(ctx, pid, {
+          lastActivityAt: Date.now()
+        });
+      }
+    }
+    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 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(
+      (edge) => DEPRECATED_TYPES.includes(edge.edgeType)
+    );
+    if (args.dryRun) {
+      return {
+        dryRun: true,
+        found: deprecatedEdges.length,
+        edges: deprecatedEdges.map((e) => ({
+          id: e._id,
+          type: e.edgeType,
+          from: e.fromNodeId,
+          to: e.toNodeId,
+          description: e.context?.description || e.description
+        })),
+        message: `Would delete ${deprecatedEdges.length} deprecated edges`
+      };
+    }
+    for (const edge of deprecatedEdges) {
+      await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+        globalId: edge.globalId
+      });
+      await ctx.db.delete(edge._id);
+    }
+    return {
+      dryRun: false,
+      deleted: deprecatedEdges.length,
+      edges: deprecatedEdges.map((e) => ({
+        id: e._id,
+        type: e.edgeType
+      })),
+      message: `Deleted ${deprecatedEdges.length} deprecated edges`
+    };
+  }
+});
+var deleteEdges = mutation({
+  args: {
+    edgeIds: v.array(v.id("epistemicEdges"))
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const deleted = [];
+    const notFound = [];
+    for (const edgeId of args.edgeIds) {
+      const edge = await ctx.db.get(edgeId);
+      if (edge) {
+        await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+          globalId: edge.globalId
+        });
+        await ctx.db.delete(edgeId);
+        deleted.push(edgeId);
+      } else {
+        notFound.push(edgeId);
+      }
+    }
+    return {
+      deleted: deleted.length,
+      notFound: notFound.length,
+      message: `Deleted ${deleted.length} edges, ${notFound.length} not found`
+    };
+  }
+});
+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(),
+    fromGlobalId: v.string(),
+    toGlobalId: v.string(),
+    edgeType: v.string(),
+    weight: v.optional(v.number()),
+    confidence: v.optional(v.number()),
+    context: v.optional(v.string()),
+    derivationType: v.optional(v.string()),
+    createdBy: v.string(),
+    ...optionalScopeArgs,
+    fromLayer: v.optional(v.string()),
+    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()),
+    validFrom: v.optional(v.number()),
+    validUntil: v.optional(v.number()),
+    constraint: v.optional(v.string()),
+    propagation: v.optional(v.string()),
+    blocking: v.optional(v.boolean()),
+    implicit: v.optional(v.boolean()),
+    conditionalA: v.optional(subjectiveOpinionValidator),
+    conditionalNotA: v.optional(subjectiveOpinionValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const fromNode = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", args.fromGlobalId)).first();
+    if (!fromNode) {
+      console.log(
+        `[Dual-Write] Skipping mirror - source node not in Convex: ${args.fromGlobalId}`
+      );
+      return { success: false, reason: "source_not_in_convex" };
+    }
+    const toNode = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", args.toGlobalId)).first();
+    const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
+    if (existing) {
+      console.log(`[Dual-Write] Edge already exists: ${args.globalId}`);
+      return { success: true, edgeId: existing._id, existed: true };
+    }
+    const now = Date.now();
+    const edgeId = await ctx.db.insert("epistemicEdges", {
+      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).
+      edgeType: args.edgeType,
+      weight: args.weight,
+      confidence: args.confidence,
+      context: args.context,
+      derivationType: args.derivationType,
+      constraint: args.constraint,
+      propagation: args.propagation,
+      blocking: args.blocking,
+      implicit: args.implicit,
+      conditionalA: args.conditionalA,
+      conditionalNotA: args.conditionalNotA,
+      createdBy: args.createdBy,
+      createdAt: now,
+      updatedAt: now,
+      topicId: args.projectId,
+      fromLayer: args.fromLayer,
+      toLayer: args.toLayer,
+      fromNodeType: args.fromNodeType,
+      toNodeType: args.toNodeType,
+      // Classification fields
+      reasoningMethod: args.reasoningMethod,
+      logicalRole: args.logicalRole,
+      temporalClass: args.temporalClass,
+      validFrom: args.validFrom,
+      validUntil: args.validUntil
+    });
+    console.log(
+      `[Dual-Write] Mirrored edge to Convex: ${args.globalId} (${args.edgeType})`
+    );
+    return { success: true, edgeId, existed: false };
+  }
+});
+var deleteEdgeFromConvex = internalMutation({
+  args: {
+    globalId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
+    if (!existing) {
+      return { success: false, reason: "not_found" };
+    }
+    await ctx.db.delete(existing._id);
+    console.log(`[Dual-Write] Deleted edge from Convex: ${args.globalId}`);
+    return { success: true };
+  }
+});
+var updateEdgeInConvex = internalMutation({
+  args: {
+    globalId: v.string(),
+    weight: v.optional(v.number()),
+    confidence: v.optional(v.number()),
+    context: v.optional(v.string()),
+    derivationType: v.optional(v.string()),
+    constraint: v.optional(v.string()),
+    propagation: v.optional(v.string()),
+    blocking: v.optional(v.boolean()),
+    implicit: v.optional(v.boolean()),
+    conditionalA: v.optional(subjectiveOpinionValidator),
+    conditionalNotA: v.optional(subjectiveOpinionValidator)
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", args.globalId)).first();
+    if (!existing) {
+      return { success: false, reason: "not_found" };
+    }
+    const updates = {
+      updatedAt: Date.now()
+    };
+    if (args.weight !== void 0) {
+      updates.weight = args.weight;
+    }
+    if (args.confidence !== void 0) {
+      updates.confidence = args.confidence;
+    }
+    if (args.context !== void 0) {
+      updates.context = args.context;
+    }
+    if (args.derivationType !== void 0) {
+      updates.derivationType = args.derivationType;
+    }
+    if (args.constraint !== void 0) {
+      updates.constraint = args.constraint;
+    }
+    if (args.propagation !== void 0) {
+      updates.propagation = args.propagation;
+    }
+    if (args.blocking !== void 0) {
+      updates.blocking = args.blocking;
+    }
+    if (args.implicit !== void 0) {
+      updates.implicit = args.implicit;
+    }
+    if (args.conditionalA !== void 0) {
+      updates.conditionalA = args.conditionalA;
+    }
+    if (args.conditionalNotA !== void 0) {
+      updates.conditionalNotA = args.conditionalNotA;
+    }
+    await ctx.db.patch(existing._id, updates);
+    console.log(`[Dual-Write] Updated edge in Convex: ${args.globalId}`);
+    return { success: true };
+  }
+});
+
+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