@lucern/graph-primitives 0.1.0-alpha.2

package/dist/epistemicQuestions.js

@@ -0,0 +1,4993 @@
+import { v } from 'convex/values';
+import { componentsGeneric, defineTable, mutationGeneric, anyApi, queryGeneric, internalQueryGeneric, internalMutationGeneric } from 'convex/server';
+
+// src/epistemicQuestions.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;
+  }
+}
+var checkProjectAccess = checkTopicAccess;
+
+// ../access-control/src/audience.ts
+var AUDIENCE_CLASS_RANK = {
+  public: 0,
+  restricted_external: 1,
+  internal: 2
+};
+function normalizeKey(key) {
+  return (key ?? "").trim().toLowerCase().replace(/[^a-z0-9:_-]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function normalizeAudienceKey(key) {
+  return normalizeKey(key);
+}
+function classFromAudienceKey(audienceKey, fallback = "internal") {
+  const key = normalizeKey(audienceKey);
+  if (!key) {
+    return fallback;
+  }
+  if (key === "internal") {
+    return "internal";
+  }
+  if (key === "public") {
+    return "public";
+  }
+  if (key === "lp" || key === "external" || key === "client" || key === "partner" || key === "portfolio" || key === "network" || key === "restricted_external") {
+    return "restricted_external";
+  }
+  return fallback;
+}
+function canAudienceClassAccess(viewerClass, resourceClass) {
+  return AUDIENCE_CLASS_RANK[viewerClass] >= AUDIENCE_CLASS_RANK[resourceClass];
+}
+
+// ../access-control/src/audienceRegistry.ts
+var DEFAULT_AUDIENCES = [
+  {
+    audienceKey: "internal",
+    audienceLabel: "Internal",
+    audienceClass: "internal"
+  },
+  {
+    audienceKey: "lp",
+    audienceLabel: "Limited Partners",
+    audienceClass: "restricted_external"
+  },
+  {
+    audienceKey: "public",
+    audienceLabel: "Public",
+    audienceClass: "public"
+  }
+];
+var AUDIENCE_CLASS_PRIORITY = {
+  internal: 0,
+  restricted_external: 1,
+  public: 2
+};
+function normalizeRegistryRow(row) {
+  return {
+    audienceKey: normalizeAudienceKey(row.audienceKey),
+    audienceLabel: row.audienceLabel,
+    audienceClass: row.audienceClass,
+    workspaceId: row.workspaceId
+  };
+}
+function dedupeRegistryRows(rows) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = normalizeAudienceKey(row.audienceKey);
+    if (!key) {
+      continue;
+    }
+    const existing = byKey.get(key);
+    const isWorkspaceScoped = row.workspaceId !== void 0;
+    const existingWorkspaceScoped = existing?.workspaceId !== void 0;
+    if (!existing || isWorkspaceScoped && !existingWorkspaceScoped) {
+      byKey.set(key, {
+        ...row,
+        audienceKey: key
+      });
+    }
+  }
+  const normalized = [...byKey.values()];
+  normalized.sort((a, b) => {
+    const classDelta = AUDIENCE_CLASS_PRIORITY[a.audienceClass] - AUDIENCE_CLASS_PRIORITY[b.audienceClass];
+    if (classDelta !== 0) {
+      return classDelta;
+    }
+    return a.audienceKey.localeCompare(b.audienceKey);
+  });
+  return normalized;
+}
+async function queryRegistryRows(ctx, args) {
+  if (!args.tenantId) {
+    return [...DEFAULT_AUDIENCES];
+  }
+  const rows = await ctx.db.query("platformAudiences").withIndex("by_tenantId", (q) => q.eq("tenantId", args.tenantId)).collect();
+  const workspaceIdString = args.workspaceId ? String(args.workspaceId) : null;
+  const tenantScoped = rows.filter((row) => row.status === "active");
+  const applicable = tenantScoped.filter((row) => {
+    if (!row.workspaceId) {
+      return true;
+    }
+    if (!workspaceIdString) {
+      return false;
+    }
+    return String(row.workspaceId) === workspaceIdString;
+  });
+  return dedupeRegistryRows([
+    ...DEFAULT_AUDIENCES,
+    ...applicable.map(
+      (row) => normalizeRegistryRow({
+        audienceKey: row.audienceKey,
+        audienceLabel: row.audienceLabel,
+        audienceClass: row.audienceClass,
+        workspaceId: row.workspaceId
+      })
+    )
+  ]);
+}
+async function listAudienceRegistryRows(ctx, args) {
+  return queryRegistryRows(ctx, args);
+}
+
+// ../access-control/src/auth.ts
+async function getCurrentUserId(ctx) {
+  const identity = await ctx.auth.getUserIdentity();
+  return identity?.subject ?? null;
+}
+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 internalQuery = internalQueryGeneric;
+var mutation = mutationGeneric;
+var query = queryGeneric;
+
+// src/embeddingTrigger.ts
+async function scheduleEmbeddingGeneration(args) {
+  try {
+    await args.ctx.scheduler.runAfter(
+      0,
+      "embeddingActions:generateEpistemicNodeEmbedding",
+      {
+        nodeId: args.nodeId,
+        projectId: args.projectId ? String(args.projectId) : void 0,
+        topicId: args.topicId ? String(args.topicId) : void 0,
+        createdBy: args.createdBy,
+        nodeType: args.nodeType,
+        text: args.text.slice(0, 2e4),
+        hasAnswer: args.hasAnswer,
+        confidence: args.confidence
+      }
+    );
+  } catch {
+  }
+}
+
+// src/globalId.ts
+function generateGlobalId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
+    ""
+  );
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// 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())
+};
+v.number();
+v.union(
+  v.literal("very_high"),
+  // 0.9+
+  v.literal("high"),
+  // 0.7-0.9
+  v.literal("medium"),
+  // 0.4-0.7
+  v.literal("low"),
+  // 0.2-0.4
+  v.literal("very_low")
+  // 0-0.2
+);
+v.union(
+  v.literal(1),
+  // Critical
+  v.literal(2),
+  // High
+  v.literal(3),
+  // Medium
+  v.literal(4),
+  // Low
+  v.literal(5)
+  // Backlog
+);
+v.union(
+  v.literal("critical"),
+  v.literal("high"),
+  v.literal("medium"),
+  v.literal("low"),
+  v.literal("backlog")
+);
+v.union(
+  v.literal("active"),
+  v.literal("paused"),
+  v.literal("completed"),
+  v.literal("archived")
+);
+v.union(
+  v.literal("pending"),
+  v.literal("processing"),
+  v.literal("completed"),
+  v.literal("failed")
+);
+v.object({
+  crunchbaseId: v.optional(v.string()),
+  linkedinUrl: v.optional(v.string()),
+  pitchbookId: v.optional(v.string()),
+  twitterUrl: v.optional(v.string()),
+  domain: v.optional(v.string())
+});
+var sourceType = v.union(
+  v.literal("proprietary"),
+  // Internal Stack research
+  v.literal("primary"),
+  // Direct interviews, calls
+  v.literal("secondary"),
+  // Published sources
+  v.literal("ai_generated"),
+  // AI-synthesized
+  v.literal("user_input"),
+  // Manual user entry
+  v.literal("inferred")
+  // System inference
+);
+v.object({
+  sourceType: v.optional(sourceType),
+  sourceId: v.optional(v.string()),
+  // Reference to source entity
+  sourceUrl: v.optional(v.string()),
+  sourceDate: v.optional(v.number()),
+  sourceName: v.optional(v.string())
+});
+v.object({
+  cursor: v.optional(v.string()),
+  limit: v.optional(v.number())
+});
+v.object({
+  hasMore: v.boolean(),
+  nextCursor: v.optional(v.string()),
+  totalCount: v.optional(v.number())
+});
+var richTextContent = v.object({
+  type: v.literal("doc"),
+  content: looseJsonArray
+});
+v.union(v.string(), richTextContent);
+v.object({
+  promptTokens: v.optional(v.number()),
+  completionTokens: v.optional(v.number()),
+  totalTokens: v.optional(v.number())
+});
+v.object({
+  fileName: v.optional(v.string()),
+  fileSize: v.optional(v.number()),
+  mimeType: v.optional(v.string()),
+  storageId: v.optional(v.id("_storage")),
+  externalUrl: v.optional(v.string())
+});
+
+// ../schema-management/src/spine/tables/epistemicNodes.ts
+var nodeType = v.union(
+  // --- L4: Audit Targets (decisions, outcomes) ---
+  v.literal("decision"),
+  // Investment decision with knowledge horizon snapshot
+  // --- L3: Traversal Anchors (epistemic structure) ---
+  v.literal("belief"),
+  // Structured conviction (immutable formulation)
+  v.literal("question"),
+  // Unit of uncertainty
+  v.literal("theme"),
+  // Investment thesis / conviction cluster
+  v.literal("deal"),
+  // Investment evaluation process
+  v.literal("topic"),
+  // Hierarchical knowledge container
+  // --- L2: Compression Boundary (minimum reasoning unit) ---
+  v.literal("claim"),
+  // Atomic assertion that can be true/false
+  v.literal("evidence"),
+  // Interpreted signal linked to beliefs
+  v.literal("synthesis"),
+  // Primers, deep research
+  v.literal("answer"),
+  // Immutable answer snapshot for a question
+  // --- L1: Terminal Leaves (non-traversable, grounding) ---
+  v.literal("atomic_fact"),
+  // Raw fact from source (not interpreted)
+  v.literal("excerpt"),
+  // Direct quote from source document
+  v.literal("source"),
+  // News, documents, transcripts
+  // --- Ontological Entities (things in the world) ---
+  v.literal("company"),
+  // Organization (subtype: private, corporate, portfolio)
+  v.literal("person"),
+  // Individual (founder, expert, LP, contact)
+  v.literal("investor"),
+  // Investment entity (subtype: vc, lp, cvc, pe, family_office, angel)
+  v.literal("function"),
+  // What a company does (from classifier)
+  v.literal("value_chain")
+  // Market structure / value flow
+);
+var epistemicLayer = v.union(
+  v.literal("L4"),
+  // Decisions, outcomes - audit targets
+  v.literal("L3"),
+  // Beliefs, questions, themes - traversal anchors
+  v.literal("L2"),
+  // Claims, evidence, synthesis - compression boundary
+  v.literal("L1"),
+  // Atomic facts, excerpts, sources - terminal leaves
+  v.literal("ontological"),
+  // Companies, people, etc - not epistemic
+  v.literal("organizational")
+  // Topics, lenses, worktrees — structural containers
+);
+var nodeStatus = v.union(
+  v.literal("active"),
+  v.literal("superseded"),
+  // Replaced by newer version
+  v.literal("archived"),
+  v.literal("deleted")
+);
+var sourceType2 = v.union(
+  v.literal("human"),
+  // User created directly
+  v.literal("ai_extracted"),
+  // LLM extracted from a source
+  v.literal("ai_generated"),
+  // LLM synthesized/created
+  v.literal("imported"),
+  // External system import
+  v.literal("system"),
+  // System-generated (migrations, classifiers)
+  v.literal("verified"),
+  // Human-verified source
+  v.literal("proprietary")
+  // Proprietary/internal data
+);
+var verificationStatus = v.union(
+  v.literal("unverified"),
+  v.literal("human_verified"),
+  v.literal("ai_verified"),
+  v.literal("contradicted"),
+  v.literal("outdated")
+);
+var syncStatus = v.union(
+  v.literal("synced"),
+  // Node and edges fully synced to Neo4j
+  v.literal("pending_edges"),
+  // Node created, edges being created
+  v.literal("edge_creation_failed")
+  // Edge creation failed, needs retry
+);
+var audienceLabel = v.string();
+var sensitivityTier = v.union(
+  v.literal("low"),
+  v.literal("medium"),
+  v.literal("high"),
+  v.literal("restricted")
+);
+var exportClass = v.union(
+  v.literal("internal_only"),
+  v.literal("client_safe"),
+  v.literal("public_safe"),
+  v.literal("restricted")
+);
+var anonymizationClass = v.union(
+  v.literal("none"),
+  v.literal("standard"),
+  v.literal("strict")
+);
+var epistemicStatus = v.union(
+  v.literal("hypothesis"),
+  // Initial conjecture, low evidence
+  v.literal("emerging"),
+  // Building evidence, gaining traction
+  v.literal("established"),
+  // Well-evidenced, core to thesis
+  v.literal("challenged"),
+  // Contradicting evidence appeared
+  v.literal("assumption"),
+  // Taken as given, not actively tested
+  v.literal("deprecated")
+  // Superseded or abandoned
+);
+var beliefStatus = v.union(
+  v.literal("assumption"),
+  v.literal("hypothesis"),
+  v.literal("belief"),
+  v.literal("fact")
+);
+var reversibility = v.union(
+  v.literal("irreversible"),
+  // One-way door decision
+  v.literal("hard_to_reverse"),
+  // Significant cost to undo
+  v.literal("reversible"),
+  // Can change course with moderate effort
+  v.literal("trivial")
+  // Easy to adjust
+);
+var predictionOutcome = v.union(
+  v.literal("pending"),
+  v.literal("confirmed"),
+  v.literal("disconfirmed"),
+  v.literal("partial"),
+  v.literal("expired")
+);
+var predictionMeta = v.object({
+  isPrediction: v.boolean(),
+  registeredAt: v.number(),
+  // When prediction was made
+  expectedBy: v.optional(v.number()),
+  // When we expect resolution
+  outcome: v.optional(predictionOutcome),
+  outcomeRecordedAt: v.optional(v.number()),
+  outcomeEvidenceId: v.optional(v.string()),
+  // globalId of confirming evidence
+  confidenceAtPrediction: v.optional(v.number()),
+  // 0-1
+  actualVsPredicted: v.optional(v.string())
+  // Notes on how outcome compared
+});
+var methodology = v.union(
+  // Primary Research (high value)
+  v.literal("primary_research"),
+  // Direct investigation
+  v.literal("expert_interview"),
+  // Expert call/interview
+  v.literal("customer_interview"),
+  // Customer research
+  v.literal("field_observation"),
+  // On-site observation
+  v.literal("proprietary_data"),
+  // Internal data analysis
+  // Secondary Research
+  v.literal("desk_research"),
+  // Public sources
+  v.literal("regulatory_filing"),
+  // SEC, regulatory docs
+  v.literal("news_article"),
+  // News/press
+  v.literal("academic_paper"),
+  // Academic research
+  // AI-Assisted
+  v.literal("ai_synthesis"),
+  // AI-generated synthesis
+  v.literal("ai_extraction")
+  // AI-extracted from source
+);
+var informationAsymmetry = v.union(
+  v.literal("proprietary"),
+  // Only we have this
+  v.literal("early"),
+  // We're early but others will get it
+  v.literal("common")
+  // Everyone has access
+);
+var temporalNature = v.union(
+  v.literal("factual"),
+  // Resolved outcome. Grounded in reality.
+  v.literal("forecast"),
+  // Prediction. Will resolve. Discounted weight.
+  v.literal("unknown")
+  // Not yet classified.
+);
+var questionType = v.union(
+  v.literal("validation"),
+  // Does evidence support this belief?
+  v.literal("falsification"),
+  // What would prove this belief wrong?
+  v.literal("assumption_probe"),
+  // Is this unstated assumption true?
+  v.literal("prediction_test"),
+  // Will this predicted outcome occur?
+  v.literal("counterfactual"),
+  // What would we expect if X were false?
+  v.literal("discovery"),
+  // What don't we know yet?
+  v.literal("clarification"),
+  // What does X actually mean?
+  v.literal("comparison"),
+  // How does X compare to Y?
+  v.literal("causal"),
+  // What caused X?
+  v.literal("mechanism"),
+  // How does X work?
+  v.literal("general")
+  // Unclassified
+);
+var questionPriority = v.union(
+  v.literal("critical"),
+  // Blocks decision-making
+  v.literal("high"),
+  // Important for thesis
+  v.literal("medium"),
+  // Would be nice to know
+  v.literal("low")
+  // Background/curiosity
+);
+var answerQuality = v.union(
+  v.literal("definitive"),
+  // Clear, well-supported
+  v.literal("strong"),
+  // Good evidence, high confidence
+  v.literal("moderate"),
+  // Some evidence
+  v.literal("weak"),
+  // Limited evidence
+  v.literal("speculative"),
+  // Mostly conjecture
+  v.literal("unanswered")
+  // No answer yet
+);
+var consensusView = v.union(
+  v.literal("aligned"),
+  // We agree with market consensus
+  v.literal("ahead_of"),
+  // We see this before consensus does
+  v.literal("contrarian"),
+  // We actively disagree with consensus
+  v.literal("orthogonal"),
+  // We're looking at something consensus isn't discussing
+  v.literal("unknown")
+  // We don't know what consensus thinks
+);
+var themeConviction = v.union(
+  v.literal("high"),
+  // Strong conviction, actively deploying
+  v.literal("medium"),
+  // Building conviction
+  v.literal("low"),
+  // Exploring, not convicted
+  v.literal("negative")
+  // Actively avoiding
+);
+var decisionType = v.union(
+  v.literal("invest"),
+  v.literal("pass"),
+  v.literal("follow_on"),
+  v.literal("exit"),
+  v.literal("deep_dive"),
+  v.literal("monitor"),
+  v.literal("deprioritize"),
+  v.literal("thesis_adopt"),
+  v.literal("thesis_revise"),
+  v.literal("thesis_abandon")
+);
+var decisionOutcome = v.union(
+  v.literal("pending"),
+  v.literal("successful"),
+  v.literal("unsuccessful"),
+  v.literal("mixed"),
+  v.literal("unknown")
+);
+var externalIds2 = v.object({
+  crunchbase: v.optional(v.string()),
+  linkedin: v.optional(v.string()),
+  pitchbook: v.optional(v.string()),
+  twitter: v.optional(v.string()),
+  website: v.optional(v.string())
+});
+defineTable({
+  // === IDENTITY ===
+  globalId: v.string(),
+  // UUID - survives migration to Neo4j
+  // === TYPE ===
+  nodeType,
+  // === EPISTEMIC LAYER ===
+  epistemicLayer: v.optional(epistemicLayer),
+  // === SUBTYPE (for typed entities) ===
+  subtype: v.optional(v.string()),
+  // company: private|corporate|portfolio, investor: vc|lp|cvc|pe|family_office|angel
+  // === CONTENT ===
+  canonicalText: v.string(),
+  // The core content (belief statement, company name, etc.)
+  contentHash: v.string(),
+  // SHA256(nodeType + canonicalText) for deduplication
+  // Extended content (for sources/syntheses)
+  content: v.optional(v.string()),
+  // Full text for documents/articles
+  contentType: v.optional(v.string()),
+  // "markdown", "html", "pdf", "text"
+  // === METADATA ===
+  title: v.optional(v.string()),
+  // Display title
+  tags: v.optional(v.array(v.string())),
+  domain: v.optional(v.string()),
+  // For companies: website domain
+  // Type-specific metadata (flexible object - LEGACY)
+  // New code should use the typed fields below when available
+  metadata: v.optional(looseJsonObject),
+  // === POLICY / ENTITLEMENT ===
+  tenantId: v.optional(v.string()),
+  workspaceId: v.optional(v.string()),
+  ownerPrincipalId: v.optional(v.string()),
+  audienceLabel: v.optional(audienceLabel),
+  policyTags: v.optional(v.array(v.string())),
+  sensitivityTier: v.optional(sensitivityTier),
+  exportClass: v.optional(exportClass),
+  anonymizationClass: v.optional(anonymizationClass),
+  // === PUBLICATION (visibility-based, not copy-based) ===
+  // Publication expands who can see a workspace-local node — the node stays
+  // in its workspace, like a microservice exposing part of its API surface.
+  // Rules-based: pack/tenant-level publicationRules auto-evaluate on
+  // confidence changes and node creation. No manual click-by-click.
+  publicationStatus: v.optional(
+    v.union(
+      v.literal("unpublished"),
+      // Default: workspace-local only
+      v.literal("published"),
+      // Visible at tenant scope (rules matched)
+      v.literal("suppressed")
+      // Manually blocked even if rules match
+    )
+  ),
+  publishedAt: v.optional(v.number()),
+  // When publication status last changed to published
+  publishedBy: v.optional(v.string()),
+  // userId or "system:publication_rules" for auto-publish
+  // === TYPED METADATA FIELDS ===
+  // --- Belief ---
+  // Belief type — validated against schemaEnumConfig category "belief_type"
+  // Platform core: hypothesis, belief, principle, invariant, assumption,
+  //                tenet, prior, preference, goal, forecast
+  beliefType: v.optional(v.string()),
+  beliefStatus: v.optional(beliefStatus),
+  epistemicStatus: v.optional(epistemicStatus),
+  reversibility: v.optional(reversibility),
+  predictionMeta: v.optional(predictionMeta),
+  // Consensus tracking (for non-consensus detection)
+  consensusView: v.optional(consensusView),
+  consensusConfidence: v.optional(v.number()),
+  // 0-1: What we think consensus confidence is
+  consensusSource: v.optional(v.string()),
+  // Where we got the consensus view (twitter, reports, etc.)
+  // --- Evidence ---
+  methodology: v.optional(methodology),
+  informationAsymmetry: v.optional(informationAsymmetry),
+  temporalNature: v.optional(temporalNature),
+  // --- Question ---
+  questionType: v.optional(questionType),
+  questionPriority: v.optional(questionPriority),
+  answerQuality: v.optional(answerQuality),
+  // --- Theme ---
+  themeConviction: v.optional(themeConviction),
+  // Market timing (for "early on theme" detection)
+  marketAwarenessDate: v.optional(v.number()),
+  // When this theme became broadly discussed
+  marketAwarenessSource: v.optional(v.string()),
+  // How we know (first major report, twitter volume spike, etc.)
+  earlySignalIds: v.optional(v.array(v.string())),
+  // globalIds of evidence we had before market awareness
+  // --- Decision ---
+  decisionType: v.optional(decisionType),
+  decisionOutcome: v.optional(decisionOutcome),
+  // === EXTERNAL IDS (for ontological entities) ===
+  externalIds: v.optional(externalIds2),
+  // === PROVENANCE ===
+  sourceType: sourceType2,
+  aiProvider: v.optional(v.string()),
+  // "claude", "gemini", "gpt-4", etc.
+  extractedFromNodeId: v.optional(v.id("epistemicNodes")),
+  // Quick reference to source
+  // === EXTRACTION CONTEXT ===
+  extractionModel: v.optional(v.string()),
+  // "claude-sonnet-4-20250514"
+  extractionPromptName: v.optional(v.string()),
+  // "lucern/extract-evidence"
+  extractionPromptVersion: v.optional(v.number()),
+  extractionTemperature: v.optional(v.number()),
+  extractionLangfuseTraceId: v.optional(v.string()),
+  // === GROUNDING VERIFICATION ===
+  groundingVerified: v.optional(v.boolean()),
+  groundingConfidence: v.optional(v.number()),
+  // 0-1 match quality
+  groundingMatchedText: v.optional(v.string()),
+  // Actual text from source
+  groundingStartOffset: v.optional(v.number()),
+  groundingEndOffset: v.optional(v.number()),
+  groundingRejectionReason: v.optional(v.string()),
+  // === CONFIDENCE & VERIFICATION ===
+  confidence: v.optional(v.number()),
+  // 0-1 projected probability P(x) = b + a*u
+  verificationStatus: v.optional(verificationStatus),
+  // === SL OPINION (Subjective Logic — Kernel v2) ===
+  // Replaces scalar confidence with rich epistemic state.
+  // b + d + u = 1. P(x) = b + a*u is stored in `confidence` for backward compat.
+  opinion_b: v.optional(v.number()),
+  // Belief: evidence FOR (0-1)
+  opinion_d: v.optional(v.number()),
+  // Disbelief: evidence AGAINST (0-1)
+  opinion_u: v.optional(v.number()),
+  // Uncertainty: absence of evidence (0-1)
+  opinion_a: v.optional(v.number()),
+  // Base rate / prior probability (0-1)
+  tupleContradicted: v.optional(v.boolean()),
+  // Single-belief tuple-space contradiction flag
+  // === LIFECYCLE ===
+  status: nodeStatus,
+  supersededBy: v.optional(v.id("epistemicNodes")),
+  // === OWNERSHIP ===
+  topicId: v.optional(v.string()),
+  // Canonical scope container (topic-first model)
+  projectId: v.optional(v.string()),
+  // DEPRECATED: Use belongs_to edges
+  createdBy: v.string(),
+  // Clerk user ID
+  createdAt: v.number(),
+  updatedAt: v.number(),
+  // === NEO4J SYNC STATUS ===
+  syncStatus: v.optional(syncStatus),
+  syncError: v.optional(v.string())
+  // Error message if sync failed
+}).index("by_globalId", ["globalId"]).index("by_contentHash", ["contentHash"]).index("by_nodeType", ["nodeType"]).index("by_subtype", ["nodeType", "subtype"]).index("by_domain", ["domain"]).index("by_project", ["projectId"]).index("by_project_type", ["projectId", "nodeType"]).index("by_topic", ["topicId"]).index("by_topic_type", ["topicId", "nodeType"]).index("by_tenantId", ["tenantId"]).index("by_workspaceId", ["workspaceId"]).index("by_tenant_workspace", ["tenantId", "workspaceId"]).index("by_audienceLabel", ["audienceLabel"]).index("by_sensitivityTier", ["sensitivityTier"]).index("by_exportClass", ["exportClass"]).index("by_status", ["status"]).index("by_sourceType", ["sourceType"]).index("by_verification", ["verificationStatus"]).index("by_layer", ["epistemicLayer"]).index("by_layer_type", ["epistemicLayer", "nodeType"]).index("by_syncStatus", ["syncStatus"]).index("by_publicationStatus", ["publicationStatus"]).index("by_tenant_publicationStatus", ["tenantId", "publicationStatus"]).index("by_belief_status", ["nodeType", "beliefStatus"]).index("by_epistemic_status", ["nodeType", "epistemicStatus"]).index("by_temporal_nature", ["nodeType", "temporalNature"]).index("by_methodology", ["nodeType", "methodology"]).index("by_reversibility", ["nodeType", "reversibility"]).index("by_questionType", ["nodeType", "questionType"]).index("by_questionPriority", ["nodeType", "questionPriority"]).searchIndex("search_canonicalText", {
+  searchField: "canonicalText",
+  filterFields: ["nodeType", "projectId", "topicId", "status"]
+});
+function getLayerForNodeType(type) {
+  switch (type) {
+    case "decision":
+      return "L4";
+    case "belief":
+    case "question":
+    case "theme":
+    case "deal":
+      return "L3";
+    case "claim":
+    case "evidence":
+    case "synthesis":
+    case "answer":
+      return "L2";
+    case "atomic_fact":
+    case "excerpt":
+    case "source":
+      return "L1";
+    case "topic":
+      return "organizational";
+    case "company":
+    case "person":
+    case "investor":
+    case "function":
+    case "value_chain":
+      return "ontological";
+  }
+}
+
+// src/workspaceIsolation.ts
+function normalizeScopeValue2(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function throwWorkspaceIsolationError(args) {
+  const error = new Error(args.message);
+  error.status = 409;
+  error.code = "INVARIANT_VIOLATION";
+  error.invariantCode = args.invariantCode;
+  error.suggestion = args.suggestion;
+  error.details = args.details;
+  throw error;
+}
+function assertWorkspaceScopedEpistemicNodeScope(args) {
+  const layer = getLayerForNodeType(args.nodeType);
+  if (layer === "ontological") {
+    return;
+  }
+  const workspaceId = normalizeScopeValue2(args.scope.workspaceId);
+  if (workspaceId) {
+    return;
+  }
+  throwWorkspaceIsolationError({
+    message: "Workspace-scoped reasoning isolation requires workspaceId on non-ontological node creation.",
+    invariantCode: "workspace.scope_required_for_epistemic_nodes",
+    suggestion: "Resolve the topic/project scope through a workspace-bound topic before creating epistemic nodes.",
+    details: {
+      mutationName: args.mutationName,
+      nodeType: args.nodeType,
+      topicId: args.scope.topicId,
+      projectId: args.scope.projectId
+    }
+  });
+}
+function nodeMatchesWorkspaceReasoningScope(node, scope) {
+  if (!node) {
+    return false;
+  }
+  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
+  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
+  const nodeTenantId = normalizeScopeValue2(node.tenantId);
+  const nodeWorkspaceId = normalizeScopeValue2(node.workspaceId);
+  const epistemicLayer2 = typeof node.epistemicLayer === "string" ? node.epistemicLayer : void 0;
+  if (scopeTenantId && nodeTenantId && scopeTenantId !== nodeTenantId) {
+    return false;
+  }
+  if (epistemicLayer2 === "ontological" && nodeWorkspaceId === void 0) {
+    return true;
+  }
+  if (!scopeWorkspaceId && node.publicationStatus === "published") {
+    return true;
+  }
+  if (!scopeWorkspaceId) {
+    return nodeWorkspaceId === void 0;
+  }
+  return scopeWorkspaceId === nodeWorkspaceId;
+}
+async function resolveNodeScopeForWorkspaceIsolation(ctx, node) {
+  const epistemicLayer2 = typeof node?.epistemicLayer === "string" ? node.epistemicLayer : void 0;
+  const resolved = {
+    tenantId: normalizeScopeValue2(node?.tenantId),
+    workspaceId: normalizeScopeValue2(node?.workspaceId),
+    epistemicLayer: epistemicLayer2,
+    nodeType: typeof node?.nodeType === "string" ? node.nodeType : void 0
+  };
+  if (!node) {
+    return resolved;
+  }
+  if (resolved.epistemicLayer === "ontological") {
+    return resolved;
+  }
+  if (resolved.tenantId || resolved.workspaceId) {
+    return resolved;
+  }
+  if (node.topicId) {
+    const topicScope = await resolveTopicProjectScope(ctx, {
+      topicId: node.topicId
+    });
+    return {
+      ...resolved,
+      tenantId: topicScope.tenantId,
+      workspaceId: topicScope.workspaceId
+    };
+  }
+  if (node.projectId) {
+    const topicScope = await resolveTopicProjectScope(ctx, {
+      projectId: String(node.projectId)
+    });
+    return {
+      ...resolved,
+      tenantId: topicScope.tenantId,
+      workspaceId: topicScope.workspaceId
+    };
+  }
+  return resolved;
+}
+function resolveRuntimePackMutationContext(args) {
+  if (!args.runtimeToolName && !args.runtimePackKey && !args.runtimePackInstallScope) {
+    return;
+  }
+  return {
+    toolName: args.runtimeToolName,
+    packKey: args.runtimePackKey,
+    packInstallScope: args.runtimePackInstallScope
+  };
+}
+function assertTenantPackWorkspaceMutationAllowed(args) {
+  if (!args.runtime?.packKey || args.runtime.packInstallScope !== "tenant") {
+    return;
+  }
+  const targetWorkspaceId = normalizeScopeValue2(args.target.workspaceId);
+  const targetLayer = typeof args.target.epistemicLayer === "string" ? args.target.epistemicLayer : void 0;
+  if (!targetWorkspaceId || targetLayer === "ontological") {
+    return;
+  }
+  throwWorkspaceIsolationError({
+    message: `Tenant-scoped pack "${args.runtime.packKey}" cannot mutate workspace-scoped reasoning state.`,
+    invariantCode: "workspace.tenant_pack_reasoning_write_forbidden",
+    suggestion: "Use a workspace-scoped pack for workspace-local graph mutations, or route the change through tenant-global canonical entity flows.",
+    details: {
+      mutationName: args.mutationName,
+      toolName: args.runtime.toolName,
+      packKey: args.runtime.packKey,
+      targetWorkspaceId,
+      targetNodeType: args.target.nodeType,
+      targetLayer
+    }
+  });
+}
+
+// ../worktrees/src/v1/engine/scopeBridge.ts
+function normalizeString2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function requireScopeId(...ids) {
+  for (const id of ids) {
+    const normalized = normalizeString2(id);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  throw new Error("No scope identifier provided (topicId or projectId required)");
+}
+async function resolveTopicProjectScope2(ctx, args) {
+  const resolved = await resolveTopicProjectScope(ctx, {
+    topicId: normalizeString2(args.topicId),
+    projectId: normalizeString2(args.projectId)
+  });
+  const topicId = normalizeString2(resolved.topicId);
+  const projectId = requireScopeId(
+    resolved.projectId,
+    args.projectId,
+    topicId
+  );
+  return { projectId, ...topicId ? { topicId } : {} };
+}
+
+// ../worktrees/src/v1/engine/worktreeWorkflowBridge.ts
+function isLegacySprintDoc(doc) {
+  if (!doc || typeof doc !== "object") {
+    return false;
+  }
+  if ("metadata" in doc && doc.metadata?.pairedSprintId) {
+    return false;
+  }
+  return "sprintScope" in doc || "targetPillar" in doc || "pillarThesis" in doc || "synthesisState" in doc || "projectId" in doc && !("worktreeScope" in doc);
+}
+function getPairedSprintId(doc) {
+  const pairedSprintId = doc?.metadata?.pairedSprintId;
+  return typeof pairedSprintId === "string" && pairedSprintId.trim().length > 0 ? pairedSprintId : null;
+}
+function getStringField(doc, field) {
+  const value = doc?.[field];
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+async function findPairedWorktreeForSprint(ctx, sprint) {
+  const sprintId = typeof sprint._id === "string" && sprint._id.length > 0 ? sprint._id : null;
+  if (!sprintId || typeof ctx.db.query !== "function") {
+    return null;
+  }
+  let topicId = getStringField(sprint, "topicId");
+  if (!topicId) {
+    try {
+      const scope = await resolveTopicProjectScope2(ctx, {
+        topicId: getStringField(sprint, "topicId"),
+        projectId: getStringField(sprint, "projectId")
+      });
+      topicId = scope.topicId;
+    } catch {
+      topicId = void 0;
+    }
+  }
+  if (!topicId) {
+    return null;
+  }
+  const worktrees = await ctx.db.query("worktrees").withIndex("by_topicId", (q) => q.eq("topicId", topicId)).collect();
+  return worktrees.find(
+    (worktree) => String(worktree?.metadata?.pairedSprintId || "") === sprintId
+  ) ?? null;
+}
+async function resolveWorkflowBridgeDoc(ctx, workflowId) {
+  const empty = {
+    inputId: workflowId ?? null,
+    sprint: null,
+    worktree: null,
+    sprintId: null,
+    worktreeId: null
+  };
+  if (!workflowId) {
+    return empty;
+  }
+  let doc;
+  try {
+    doc = await ctx.db.get(workflowId);
+  } catch {
+    return empty;
+  }
+  if (!doc || typeof doc !== "object") {
+    return empty;
+  }
+  if (isLegacySprintDoc(doc)) {
+    const worktree2 = await findPairedWorktreeForSprint(ctx, doc);
+    return {
+      ...empty,
+      sprint: doc,
+      worktree: worktree2,
+      sprintId: typeof doc._id === "string" && doc._id.length > 0 ? doc._id : workflowId,
+      worktreeId: worktree2 && typeof worktree2._id === "string" && worktree2._id.length > 0 ? worktree2._id : null,
+      topicId: getStringField(worktree2, "topicId") ?? getStringField(doc, "topicId"),
+      projectId: getStringField(doc, "projectId") ?? getStringField(worktree2, "projectId")
+    };
+  }
+  const worktree = doc;
+  const pairedSprintId = getPairedSprintId(worktree);
+  let sprint = null;
+  if (pairedSprintId) {
+    try {
+      const paired = await ctx.db.get(pairedSprintId);
+      if (isLegacySprintDoc(paired)) {
+        sprint = paired;
+      }
+    } catch {
+      sprint = null;
+    }
+  }
+  return {
+    ...empty,
+    worktree,
+    sprint,
+    worktreeId: typeof worktree._id === "string" && worktree._id.length > 0 ? worktree._id : workflowId,
+    sprintId: sprint && typeof sprint._id === "string" && sprint._id.length > 0 ? sprint._id : pairedSprintId,
+    topicId: getStringField(worktree, "topicId") ?? getStringField(sprint, "topicId"),
+    projectId: getStringField(sprint, "projectId") ?? getStringField(worktree, "projectId")
+  };
+}
+
+// src/epistemicQuestions.ts
+function generateContentHash(text) {
+  const content2 = `question:${text.trim().toLowerCase().replace(/\s+/g, " ")}`;
+  let hash = 5381;
+  for (let i = 0; i < content2.length; i++) {
+    hash = (hash << 5) + hash + content2.charCodeAt(i);
+    hash &= hash;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+function buildTestsEdgeGlobalId(fromGlobalId, toGlobalId) {
+  return `edge-${fromGlobalId}-tests-${toGlobalId}`;
+}
+async function markProjectGraphDirty(ctx, projectId, topicId) {
+  const normalizedProjectId = typeof projectId === "string" && projectId.trim().length > 0 ? projectId : void 0;
+  const normalizedTopicId = typeof topicId === "string" && topicId.trim().length > 0 ? topicId : void 0;
+  if (!normalizedProjectId && !normalizedTopicId) {
+    return;
+  }
+  if (normalizedProjectId) {
+    await ctx.scheduler.runAfter(
+      0,
+      internal.graphAnalysisCache.markCacheStaleInternal,
+      {
+        projectId: normalizedProjectId
+      }
+    );
+  }
+  if (normalizedTopicId) {
+    await ctx.scheduler.runAfter(
+      0,
+      internal.graphAnalysisCache.markCacheStaleByTopic,
+      {
+        topicId: normalizedTopicId
+      }
+    );
+  }
+  await resolveGraphPrimitivesAppResolvers().patchProject(
+    ctx,
+    normalizedTopicId ?? normalizedProjectId,
+    {
+      lastActivityAt: Date.now()
+    }
+  );
+}
+function normalizeCategory(category) {
+  if (!category) {
+    return "other";
+  }
+  const lower = category.toLowerCase();
+  if (lower === "financial") {
+    return "financials";
+  }
+  const validCategories = [
+    "market",
+    "competition",
+    "product",
+    "team",
+    "financials",
+    "deal",
+    "risks"
+  ];
+  return validCategories.find((c) => lower.includes(c)) || "other";
+}
+var DEFAULT_QUESTION_PAGE_SIZE = 250;
+var MAX_QUESTION_PAGE_SIZE = 1e3;
+function clampQuestionLimit(limit, fallback = DEFAULT_QUESTION_PAGE_SIZE) {
+  if (!Number.isFinite(limit)) {
+    return fallback;
+  }
+  return Math.max(
+    1,
+    Math.min(Math.floor(limit), MAX_QUESTION_PAGE_SIZE)
+  );
+}
+function dedupeQuestionNodes(nodes) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const node of nodes) {
+    const id = String(node._id);
+    if (seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    deduped.push(node);
+  }
+  return deduped;
+}
+function normalizeQuestionTopicId(topicId) {
+  return typeof topicId === "string" && topicId.trim().length > 0 ? topicId : void 0;
+}
+function resolveQuestionScopeId(scope) {
+  return normalizeQuestionTopicId(scope.topicId) ?? scope.projectId ?? void 0;
+}
+async function resolveQuestionScopeOrNull(ctx, args) {
+  if (!args.projectId && !args.topicId) {
+    return null;
+  }
+  try {
+    return await resolveTopicProjectScope(ctx, {
+      projectId: args.projectId ?? void 0,
+      topicId: args.topicId ?? void 0
+    });
+  } catch {
+    return null;
+  }
+}
+async function getQuestionNodesForScope(ctx, scope, args) {
+  const fetchNodes = (query2) => typeof args?.scanLimit === "number" ? query2.order("desc").take(args.scanLimit) : query2.collect();
+  const [topicNodes, projectNodes] = await Promise.all([
+    scope.topicId ? fetchNodes(
+      ctx.db.query("epistemicNodes").withIndex(
+        "by_topic_type",
+        (q) => q.eq("topicId", scope.topicId).eq("nodeType", "question")
+      )
+    ) : Promise.resolve([]),
+    scope.projectId ? fetchNodes(
+      ctx.db.query("epistemicNodes").withIndex(
+        "by_project_type",
+        (q) => q.eq("projectId", scope.projectId).eq("nodeType", "question")
+      )
+    ) : Promise.resolve([])
+  ]);
+  return dedupeQuestionNodes([...topicNodes, ...projectNodes]).filter(
+    (node) => questionMatchesScope(node, scope)
+  );
+}
+async function getQuestionEdgesForScope(ctx, scope) {
+  const query2 = ctx.db.query("epistemicEdges").withIndex(
+    "by_topic",
+    (q) => q.eq("topicId", scope.topicId || scope.projectId)
+  );
+  return await query2.collect();
+}
+function questionMatchesScope(node, scope) {
+  return scope.topicId !== void 0 && node.topicId === scope.topicId || scope.projectId !== void 0 && node.projectId === scope.projectId;
+}
+function resolveLinkedWorktreeId(meta) {
+  const linkedWorktreeId = meta.linkedWorktreeId;
+  return typeof linkedWorktreeId === "string" && linkedWorktreeId.trim() ? linkedWorktreeId : null;
+}
+function buildLinkedWorktreeMetadata(linkedWorktreeId) {
+  return linkedWorktreeId ? {
+    linkedWorktreeId
+  } : {};
+}
+function questionMatchesWorkflowLink(meta, workflow) {
+  const linkedWorktreeId = resolveLinkedWorktreeId(meta);
+  return Boolean(
+    linkedWorktreeId && (linkedWorktreeId === workflow.worktreeId || linkedWorktreeId === workflow.sprintId)
+  );
+}
+function flattenQuestionNode(n) {
+  const meta = n.metadata || {};
+  const linkedWorktreeId = resolveLinkedWorktreeId(meta);
+  return {
+    ...n,
+    question: n.canonicalText || "",
+    category: meta.category || "other",
+    priority: meta.priority || "medium",
+    status: meta.questionStatus || meta.status || "open",
+    beliefId: meta.linkedBeliefNodeId || meta.beliefId || null,
+    relatedBeliefIds: meta.relatedBeliefIds || [],
+    relatedInsightIds: meta.relatedInsightIds || [],
+    linkedWorktreeId,
+    sprintIndex: meta.sprintIndex || void 0,
+    linkedBeliefId: meta.linkedBeliefNodeId || null,
+    testType: meta.testType || "validates",
+    importance: meta.importance || 5,
+    isKeyQuestion: meta.isKeyQuestion || false,
+    answer: meta.answer || null,
+    convictionStage: meta.convictionStage || null,
+    conviction: meta.conviction ?? null,
+    source: meta.source || "ai_suggested"
+  };
+}
+function flattenInternalQuestionNode(n) {
+  const meta = n.metadata || {};
+  const flattened = flattenQuestionNode(n);
+  return {
+    ...flattened,
+    _epistemicNodeId: n._id,
+    questionType: n.questionType || meta.questionType || flattened.testType,
+    linkedBeliefIds: flattened.relatedBeliefIds,
+    audienceLabel: n.audienceLabel,
+    policyTags: n.policyTags,
+    sensitivityTier: n.sensitivityTier,
+    exportClass: n.exportClass,
+    anonymizationClass: n.anonymizationClass
+  };
+}
+var INACTIVE_NODE_STATUSES = /* @__PURE__ */ new Set(["archived", "superseded", "deleted"]);
+var INACTIVE_METADATA_STATUSES = /* @__PURE__ */ new Set([
+  "archived",
+  "superseded",
+  "deleted"
+]);
+function getQuestionStatusCandidates(node) {
+  const meta = node.metadata || {};
+  return [meta.questionStatus, meta.status, node.status].filter(
+    (value) => typeof value === "string"
+  );
+}
+function isActiveQuestionNode(node) {
+  if (INACTIVE_NODE_STATUSES.has(node.status)) {
+    return false;
+  }
+  return !getQuestionStatusCandidates(node).some(
+    (status) => INACTIVE_METADATA_STATUSES.has(status.toLowerCase())
+  );
+}
+function matchesRequestedQuestionStatus(node, requestedStatus) {
+  const normalizedStatus = requestedStatus.toLowerCase();
+  return getQuestionStatusCandidates(node).some(
+    (status) => status.toLowerCase() === normalizedStatus
+  );
+}
+var create = mutation({
+  args: {
+    ...optionalScopeArgs,
+    question: v.string(),
+    category: v.optional(v.string()),
+    priority: v.optional(
+      v.union(v.literal("high"), v.literal("medium"), v.literal("low"))
+    ),
+    source: v.optional(v.string()),
+    userId: v.string(),
+    // Optional linking
+    linkedBeliefNodeId: v.optional(v.id("epistemicNodes")),
+    testType: v.optional(
+      v.union(
+        v.literal("validates"),
+        v.literal("invalidates"),
+        v.literal("clarifies")
+      )
+    ),
+    // Optional metadata
+    importance: v.optional(v.number()),
+    epistemicUnlock: v.optional(v.string()),
+    // === SOURCE QUESTIONS (for key question derivation) ===
+    // When a key question is synthesized from raw questions, track the source
+    sourceQuestionIds: v.optional(v.array(v.string())),
+    // globalIds of source questions
+    // === WORKTREE LINKAGE ===
+    linkedWorktreeId: v.optional(v.string()),
+    // === CLASSIFICATION FIELDS ===
+    questionType: v.optional(
+      v.union(
+        v.literal("validation"),
+        v.literal("falsification"),
+        v.literal("assumption_probe"),
+        v.literal("prediction_test"),
+        v.literal("counterfactual"),
+        v.literal("discovery"),
+        v.literal("clarification"),
+        v.literal("comparison"),
+        v.literal("causal"),
+        v.literal("mechanism"),
+        v.literal("general")
+      )
+    ),
+    questionPriority: v.optional(
+      v.union(
+        v.literal("critical"),
+        v.literal("high"),
+        v.literal("medium"),
+        v.literal("low")
+      )
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveTopicProjectScope(ctx, {
+      topicId: args.topicId,
+      projectId: args.projectId
+    });
+    assertWorkspaceScopedEpistemicNodeScope({
+      scope,
+      nodeType: "question",
+      mutationName: "epistemicQuestions.create"
+    });
+    if (scope.projectId) {
+      await checkProjectAccess(ctx, scope.projectId, args.userId);
+    }
+    const now = Date.now();
+    const globalId = generateGlobalId();
+    const contentHash = generateContentHash(args.question);
+    const category = normalizeCategory(args.category);
+    const nodeId = await ctx.db.insert("epistemicNodes", {
+      globalId,
+      topicId: scope.topicId,
+      projectId: scope.projectId,
+      tenantId: scope.tenantId,
+      workspaceId: scope.workspaceId,
+      nodeType: "question",
+      canonicalText: args.question,
+      contentHash,
+      status: "active",
+      epistemicLayer: "L3",
+      // L3: Traversal Anchors (Questions)
+      sourceType: args.source === "user" ? "human" : "ai_generated",
+      // Classification fields
+      questionType: args.questionType ?? "general",
+      questionPriority: args.questionPriority ?? "medium",
+      answerQuality: "unanswered",
+      // New questions start unanswered
+      createdAt: now,
+      updatedAt: now,
+      createdBy: args.userId,
+      metadata: {
+        category,
+        priority: args.priority || "medium",
+        source: args.source || "ai_suggested",
+        questionStatus: "open",
+        linkedBeliefNodeId: args.linkedBeliefNodeId,
+        ...buildLinkedWorktreeMetadata(
+          args.linkedWorktreeId
+        ),
+        testType: args.testType,
+        importance: args.importance,
+        epistemicUnlock: args.epistemicUnlock,
+        // Track source questions for key question derivation
+        prerequisiteQuestions: args.sourceQuestionIds
+      }
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId,
+      operation: "upsert"
+    });
+    await scheduleEmbeddingGeneration({
+      ctx,
+      nodeId,
+      projectId: scope.projectId,
+      topicId: scope.topicId,
+      createdBy: args.userId,
+      nodeType: "question",
+      text: args.question
+    });
+    if (args.linkedBeliefNodeId) {
+      const beliefNode = await ctx.db.get(args.linkedBeliefNodeId);
+      if (beliefNode?.globalId) {
+        await ctx.scheduler.runAfter(100, internal.neo4jSync.syncNodeToNeo4j, {
+          nodeId: args.linkedBeliefNodeId,
+          operation: "upsert"
+        });
+        const edgeGlobalId = buildTestsEdgeGlobalId(
+          beliefNode.globalId,
+          globalId
+        );
+        await ctx.scheduler.runAfter(250, internal.neo4jEdgeAPI.createEdge, {
+          globalId: edgeGlobalId,
+          fromGlobalId: beliefNode.globalId,
+          toGlobalId: globalId,
+          edgeType: "tests",
+          weight: 1,
+          context: args.testType || "tests",
+          createdBy: args.userId,
+          topicId: scope.projectId ? String(scope.projectId) : void 0,
+          fromNodeType: "belief",
+          toNodeType: "question",
+          fromLayer: "L3",
+          toLayer: "L3"
+        });
+      }
+    }
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "question",
+      entityId: nodeId,
+      changeType: "created",
+      changedAt: now,
+      changedBy: args.userId,
+      isAgent: false,
+      projectId: scope.projectId,
+      newState: {
+        question: args.question,
+        category,
+        priority: args.priority || "medium"
+      }
+    });
+    if (scope.projectId || scope.topicId) {
+      await ctx.scheduler.runAfter(
+        0,
+        "embeddingActions:generateEpistemicNodeEmbedding",
+        {
+          nodeId,
+          projectId: scope.projectId,
+          topicId: scope.topicId ? String(scope.topicId) : void 0,
+          createdBy: args.userId,
+          nodeType: "question",
+          text: args.question,
+          hasAnswer: false
+        }
+      );
+    }
+    if (scope.projectId || scope.topicId) {
+      await ctx.scheduler.runAfter(
+        2e3,
+        // 2 second delay
+        internal.nodeClassification.scheduleClassification,
+        {
+          nodeId,
+          nodeType: "question",
+          projectId: scope.projectId,
+          topicId: normalizeQuestionTopicId(scope.topicId)
+        }
+      );
+    }
+    await markProjectGraphDirty(
+      ctx,
+      scope.projectId,
+      normalizeQuestionTopicId(scope.topicId)
+    );
+    return { nodeId };
+  }
+});
+var createBatch = mutation({
+  args: {
+    ...optionalScopeArgs,
+    questions: v.array(
+      v.object({
+        question: v.string(),
+        category: v.optional(v.string()),
+        priority: v.optional(
+          v.union(v.literal("high"), v.literal("medium"), v.literal("low"))
+        ),
+        linkedBeliefNodeId: v.optional(v.id("epistemicNodes")),
+        testType: v.optional(
+          v.union(
+            v.literal("validates"),
+            v.literal("invalidates"),
+            v.literal("clarifies")
+          )
+        )
+      })
+    ),
+    source: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveTopicProjectScope(ctx, {
+      topicId: args.topicId,
+      projectId: args.projectId
+    });
+    const scopeId = resolveQuestionScopeId(scope);
+    if (!scopeId) {
+      throw new Error("No scope identifier provided");
+    }
+    const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+    if (!hasAccess) {
+      throw new Error("Access denied");
+    }
+    const now = Date.now();
+    const nodeIds = [];
+    for (const q of args.questions) {
+      const globalId = generateGlobalId();
+      const contentHash = generateContentHash(q.question);
+      const category = normalizeCategory(q.category);
+      const nodeId = await ctx.db.insert("epistemicNodes", {
+        globalId,
+        topicId: scope.topicId,
+        projectId: scope.projectId,
+        tenantId: scope.tenantId,
+        workspaceId: scope.workspaceId,
+        nodeType: "question",
+        canonicalText: q.question,
+        contentHash,
+        status: "active",
+        epistemicLayer: "L3",
+        sourceType: args.source === "user" ? "human" : "ai_generated",
+        createdAt: now,
+        updatedAt: now,
+        createdBy: args.userId,
+        metadata: {
+          category,
+          priority: q.priority || "medium",
+          source: args.source || "ai_suggested",
+          questionStatus: "open",
+          linkedBeliefNodeId: q.linkedBeliefNodeId,
+          testType: q.testType
+        }
+      });
+      nodeIds.push(nodeId);
+      await ctx.db.insert("epistemicAudit", {
+        entityType: "question",
+        entityId: String(nodeId),
+        changeType: "created",
+        changedAt: now,
+        changedBy: args.userId,
+        isAgent: false,
+        projectId: scope.projectId,
+        topicId: normalizeQuestionTopicId(scope.topicId),
+        newState: {
+          question: q.question,
+          category,
+          priority: q.priority || "medium",
+          source: args.source || "ai_suggested",
+          linkedBeliefNodeId: q.linkedBeliefNodeId,
+          testType: q.testType
+        },
+        triggeringAction: "epistemicQuestions.createBatch"
+      });
+      await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+        nodeId,
+        operation: "upsert"
+      });
+      if (q.linkedBeliefNodeId) {
+        const beliefNode = await ctx.db.get(q.linkedBeliefNodeId);
+        if (beliefNode) {
+          await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+            globalId: crypto.randomUUID(),
+            fromGlobalId: beliefNode.globalId,
+            toGlobalId: globalId,
+            edgeType: "tests",
+            weight: 1,
+            createdBy: args.userId,
+            topicId: scope.projectId,
+            fromNodeType: "belief",
+            toNodeType: "question",
+            fromLayer: "L3",
+            toLayer: "L3"
+          });
+        }
+      }
+    }
+    await markProjectGraphDirty(
+      ctx,
+      scope.projectId,
+      normalizeQuestionTopicId(scope.topicId)
+    );
+    return { nodeIds, count: nodeIds.length };
+  }
+});
+var updateStatus = mutation({
+  args: {
+    nodeId: v.optional(v.id("epistemicNodes")),
+    // Backward compatibility for older callers still sending questionId.
+    questionId: v.optional(v.union(v.id("epistemicNodes"), v.string())),
+    status: v.union(
+      v.literal("open"),
+      v.literal("researching"),
+      v.literal("answered"),
+      v.literal("parked"),
+      v.literal("closed")
+    ),
+    userId: v.optional(v.string()),
+    answer: v.optional(v.string()),
+    answerStatus: v.optional(
+      v.union(
+        v.literal("ai_draft"),
+        v.literal("user_draft"),
+        v.literal("final")
+      )
+    ),
+    runtimeToolName: v.optional(v.string()),
+    runtimePackKey: v.optional(v.string()),
+    runtimePackInstallScope: v.optional(
+      v.union(v.literal("tenant"), v.literal("workspace"))
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const resolvedNodeId = args.nodeId ?? args.questionId;
+    if (!resolvedNodeId) {
+      throw new Error("Missing nodeId/questionId");
+    }
+    const resolvedUserId = args.userId || await getCurrentUserId(ctx);
+    if (!resolvedUserId) {
+      throw new Error("Not authenticated");
+    }
+    const node = await ctx.db.get(resolvedNodeId);
+    if (!node || node.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    assertTenantPackWorkspaceMutationAllowed({
+      runtime: resolveRuntimePackMutationContext(args),
+      target: await resolveNodeScopeForWorkspaceIsolation(ctx, node),
+      mutationName: "epistemicQuestions.updateStatus"
+    });
+    const now = Date.now();
+    const metadata = node.metadata || {};
+    const previousStatus = metadata.questionStatus || "open";
+    await ctx.db.patch(resolvedNodeId, {
+      updatedAt: now,
+      metadata: {
+        ...metadata,
+        questionStatus: args.status,
+        answer: args.answer || metadata.answer,
+        answerStatus: args.answerStatus || metadata.answerStatus,
+        answeredAt: args.status === "answered" ? now : metadata.answeredAt,
+        answeredBy: args.status === "answered" ? resolvedUserId : metadata.answeredBy
+      }
+    });
+    if (args.status === "answered" && args.answer) {
+      await ctx.scheduler.runAfter(
+        0,
+        internal.epistemicAnswers.createInternal,
+        {
+          projectId: node.projectId,
+          topicId: normalizeQuestionTopicId(node.topicId),
+          questionNodeId: resolvedNodeId,
+          answerText: args.answer,
+          answerSource: "human",
+          userId: resolvedUserId
+        }
+      );
+    }
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "question",
+      entityId: resolvedNodeId,
+      changeType: "status_changed",
+      changedAt: now,
+      changedBy: resolvedUserId,
+      isAgent: false,
+      projectId: node.projectId,
+      previousState: { status: previousStatus },
+      newState: { status: args.status }
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: resolvedNodeId,
+      operation: "upsert"
+    });
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+    return { nodeId: resolvedNodeId, previousStatus, newStatus: args.status };
+  }
+});
+var updatePriority = mutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    priority: v.union(v.literal("high"), v.literal("medium"), v.literal("low")),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = await ctx.db.get(args.nodeId);
+    if (!node || node.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    const now = Date.now();
+    const metadata = node.metadata || {};
+    const previousPriority = metadata.priority || "medium";
+    await ctx.db.patch(args.nodeId, {
+      updatedAt: now,
+      metadata: {
+        ...metadata,
+        priority: args.priority
+      }
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "question",
+      entityId: args.nodeId,
+      changeType: "priority_changed",
+      changedAt: now,
+      changedBy: args.userId,
+      isAgent: false,
+      projectId: node.projectId,
+      previousState: { priority: previousPriority },
+      newState: { priority: args.priority }
+    });
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+    return { nodeId: args.nodeId };
+  }
+});
+var getById = query({
+  args: {
+    nodeId: v.optional(v.id("epistemicNodes")),
+    questionId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const id = args.nodeId ?? args.questionId;
+    if (!id) {
+      return null;
+    }
+    const node = await ctx.db.get(
+      id
+    );
+    if (!node || node.nodeType !== "question") {
+      return null;
+    }
+    return flattenQuestionNode(node);
+  }
+});
+var getByProject = query({
+  args: {
+    ...optionalScopeArgs,
+    status: v.optional(v.string()),
+    userId: v.optional(v.string()),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveQuestionScopeOrNull(ctx, args);
+    if (!scope) {
+      return [];
+    }
+    const pageSize = clampQuestionLimit(args.limit);
+    const scanLimit = Math.min(pageSize * 3, MAX_QUESTION_PAGE_SIZE);
+    if (args.userId) {
+      const scopeId = resolveQuestionScopeId(scope);
+      if (!scopeId) {
+        return [];
+      }
+      const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+      if (!hasAccess) {
+        return [];
+      }
+    }
+    const workspaceScopedNodes = await getQuestionNodesForScope(ctx, scope, {
+      scanLimit
+    });
+    const scopedNodes = args.status ? workspaceScopedNodes.filter(
+      (node) => matchesRequestedQuestionStatus(node, args.status)
+    ) : workspaceScopedNodes.filter(isActiveQuestionNode);
+    return scopedNodes.map(flattenQuestionNode).slice(0, pageSize);
+  }
+});
+var getByTopic = query({
+  args: {
+    topicId: v.string(),
+    status: v.optional(v.string()),
+    userId: v.optional(v.string()),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const pageSize = clampQuestionLimit(args.limit);
+    const scanLimit = Math.min(pageSize * 3, MAX_QUESTION_PAGE_SIZE);
+    const scope = await resolveTopicProjectScope(ctx, { topicId: args.topicId });
+    const scopedNodes = await getQuestionNodesForScope(ctx, scope, {
+      scanLimit
+    });
+    const filteredNodes = args.status ? scopedNodes.filter(
+      (node) => matchesRequestedQuestionStatus(node, args.status)
+    ) : scopedNodes.filter(isActiveQuestionNode);
+    return filteredNodes.map(flattenQuestionNode).slice(0, pageSize);
+  }
+});
+var getByCategory = query({
+  args: {
+    ...optionalScopeArgs,
+    category: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveQuestionScopeOrNull(ctx, args);
+    if (!scope) {
+      return [];
+    }
+    const nodes = await getQuestionNodesForScope(ctx, scope);
+    return nodes.filter((n) => {
+      const metadata = n.metadata || {};
+      return questionMatchesScope(n, scope) && (isActiveQuestionNode(n) && metadata.category === normalizeCategory(args.category));
+    });
+  }
+});
+var getForBelief = query({
+  args: {
+    beliefNodeId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const edges = await ctx.db.query("epistemicEdges").withIndex(
+      "by_from_type",
+      (q) => q.eq("fromNodeId", args.beliefNodeId).eq("edgeType", "tests")
+    ).collect();
+    const questionNodeIds = edges.map((e) => e.toNodeId).filter(Boolean);
+    const questions = await Promise.all(
+      questionNodeIds.map((id) => ctx.db.get(id))
+    );
+    return questions.filter(
+      (q) => q !== null && q.nodeType === "question" && isActiveQuestionNode(q)
+    );
+  }
+});
+var internalGetByProject = internalQuery({
+  args: {
+    ...optionalScopeArgs,
+    status: v.optional(v.string()),
+    limit: v.optional(v.number()),
+    audienceMode: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const pageSize = clampQuestionLimit(args.limit, 500);
+    const scanLimit = Math.min(pageSize * 3, MAX_QUESTION_PAGE_SIZE);
+    const audienceMode = args.audienceMode ?? "internal";
+    const scope = await resolveTopicProjectScope(ctx, {
+      projectId: args.projectId,
+      topicId: args.topicId
+    });
+    const projectScopeId = resolveQuestionScopeId(scope);
+    if (!projectScopeId) {
+      return [];
+    }
+    const project = await resolveGraphPrimitivesAppResolvers().getProject(
+      ctx,
+      projectScopeId
+    );
+    const registryRows = await listAudienceRegistryRows(ctx, {
+      tenantId: project?.tenantId,
+      workspaceId: project?.workspaceId
+    });
+    const audienceClassByKey = new Map(
+      registryRows.map((row) => [
+        normalizeAudienceKey(row.audienceKey),
+        row.audienceClass
+      ])
+    );
+    const resolveAudienceClass = (audienceKey, fallback) => {
+      const key = normalizeAudienceKey(audienceKey);
+      if (!key) {
+        return fallback;
+      }
+      return audienceClassByKey.get(key) ?? classFromAudienceKey(key, fallback);
+    };
+    const viewerClass = resolveAudienceClass(audienceMode, "public");
+    const nodes = await getQuestionNodesForScope(ctx, scope, { scanLimit });
+    const workspaceScopedNodes = nodes.filter(
+      (node) => nodeMatchesWorkspaceReasoningScope(node, {
+        tenantId: project?.tenantId,
+        workspaceId: project?.workspaceId
+      })
+    );
+    const visibleNodes = workspaceScopedNodes.filter(
+      (node) => canAudienceClassAccess(
+        viewerClass,
+        resolveAudienceClass(node.audienceLabel, "internal")
+      )
+    );
+    const scopedNodes = args.status ? visibleNodes.filter(
+      (node) => matchesRequestedQuestionStatus(node, args.status)
+    ) : visibleNodes.filter(isActiveQuestionNode);
+    return scopedNodes.slice(0, pageSize).map(flattenInternalQuestionNode);
+  }
+});
+var internalGetByTopic = internalQuery({
+  args: {
+    topicId: v.string(),
+    status: v.optional(v.string()),
+    limit: v.optional(v.number()),
+    audienceMode: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const pageSize = clampQuestionLimit(args.limit, 500);
+    const scanLimit = Math.min(pageSize * 3, MAX_QUESTION_PAGE_SIZE);
+    const audienceMode = args.audienceMode ?? "internal";
+    const scope = await resolveTopicProjectScope(ctx, { topicId: args.topicId });
+    const registryRows = await listAudienceRegistryRows(ctx, {
+      tenantId: scope.tenantId,
+      workspaceId: scope.workspaceId
+    });
+    const audienceClassByKey = new Map(
+      registryRows.map((row) => [
+        normalizeAudienceKey(row.audienceKey),
+        row.audienceClass
+      ])
+    );
+    const resolveAudienceClass = (audienceKey, fallback) => {
+      const key = normalizeAudienceKey(audienceKey);
+      if (!key) {
+        return fallback;
+      }
+      return audienceClassByKey.get(key) ?? classFromAudienceKey(key, fallback);
+    };
+    const viewerClass = resolveAudienceClass(audienceMode, "public");
+    const nodes = await getQuestionNodesForScope(ctx, scope, { scanLimit });
+    const workspaceScopedNodes = nodes.filter(
+      (node) => nodeMatchesWorkspaceReasoningScope(node, {
+        tenantId: scope.tenantId,
+        workspaceId: scope.workspaceId
+      })
+    );
+    const visibleNodes = workspaceScopedNodes.filter(
+      (node) => canAudienceClassAccess(
+        viewerClass,
+        resolveAudienceClass(node.audienceLabel, "internal")
+      )
+    );
+    const scopedNodes = args.status ? visibleNodes.filter(
+      (node) => matchesRequestedQuestionStatus(node, args.status)
+    ) : visibleNodes.filter(isActiveQuestionNode);
+    return scopedNodes.slice(0, pageSize).map(flattenInternalQuestionNode);
+  }
+});
+var internalCreate = internalMutation({
+  args: {
+    ...optionalScopeArgs,
+    question: v.string(),
+    category: v.optional(v.string()),
+    priority: v.optional(v.string()),
+    source: v.optional(v.string()),
+    userId: v.string(),
+    linkedBeliefNodeId: v.optional(v.id("epistemicNodes")),
+    testType: v.optional(v.string()),
+    runtimeToolName: v.optional(v.string()),
+    runtimePackKey: v.optional(v.string()),
+    runtimePackInstallScope: v.optional(
+      v.union(v.literal("tenant"), v.literal("workspace"))
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const scope = await resolveTopicProjectScope(ctx, {
+      topicId: args.topicId,
+      projectId: args.projectId
+    });
+    assertWorkspaceScopedEpistemicNodeScope({
+      scope,
+      nodeType: "question",
+      mutationName: "epistemicQuestions.internalCreate"
+    });
+    assertTenantPackWorkspaceMutationAllowed({
+      runtime: resolveRuntimePackMutationContext(args),
+      target: {
+        tenantId: scope.tenantId,
+        workspaceId: scope.workspaceId,
+        nodeType: "question",
+        epistemicLayer: "L3"
+      },
+      mutationName: "epistemicQuestions.internalCreate"
+    });
+    const globalId = generateGlobalId();
+    const contentHash = generateContentHash(args.question);
+    const category = normalizeCategory(args.category);
+    const nodeId = await ctx.db.insert("epistemicNodes", {
+      globalId,
+      topicId: scope.topicId,
+      projectId: scope.projectId,
+      tenantId: scope.tenantId,
+      workspaceId: scope.workspaceId,
+      nodeType: "question",
+      canonicalText: args.question,
+      contentHash,
+      status: "active",
+      epistemicLayer: "L3",
+      sourceType: args.source === "user" ? "human" : "ai_generated",
+      createdAt: now,
+      updatedAt: now,
+      createdBy: args.userId,
+      metadata: {
+        category,
+        priority: args.priority || "medium",
+        source: args.source || "ai_suggested",
+        questionStatus: "open",
+        linkedBeliefNodeId: args.linkedBeliefNodeId,
+        testType: args.testType
+      }
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId,
+      operation: "upsert"
+    });
+    if (args.linkedBeliefNodeId) {
+      const beliefNode = await ctx.db.get(args.linkedBeliefNodeId);
+      if (beliefNode) {
+        await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+          globalId: crypto.randomUUID(),
+          fromGlobalId: beliefNode.globalId,
+          toGlobalId: globalId,
+          edgeType: "tests",
+          weight: 1,
+          createdBy: args.userId,
+          topicId: scope.projectId ? String(scope.projectId) : void 0,
+          fromNodeType: "belief",
+          toNodeType: "question",
+          fromLayer: "L3",
+          toLayer: "L3"
+        });
+      }
+    }
+    if (scope.projectId || scope.topicId) {
+      await ctx.scheduler.runAfter(
+        0,
+        "embeddingActions:generateEpistemicNodeEmbedding",
+        {
+          nodeId,
+          projectId: scope.projectId,
+          topicId: scope.topicId ? String(scope.topicId) : void 0,
+          createdBy: args.userId,
+          nodeType: "question",
+          text: args.question,
+          hasAnswer: false
+        }
+      );
+    }
+    await markProjectGraphDirty(
+      ctx,
+      scope.projectId,
+      normalizeQuestionTopicId(scope.topicId)
+    );
+    return { nodeId };
+  }
+});
+var addQuestion = mutation({
+  args: {
+    ...optionalScopeArgs,
+    question: v.string(),
+    category: v.optional(v.string()),
+    priority: v.optional(v.string()),
+    source: v.optional(v.string()),
+    userId: v.string(),
+    beliefId: v.optional(v.string()),
+    chatId: v.optional(v.string()),
+    importance: v.optional(v.number()),
+    epistemicUnlock: v.optional(v.string()),
+    metadata: v.optional(v.any()),
+    questionType: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveTopicProjectScope(ctx, {
+      topicId: args.topicId,
+      projectId: args.projectId
+    });
+    const scopeId = resolveQuestionScopeId(scope);
+    if (!scopeId) {
+      throw new Error("No scope identifier provided");
+    }
+    const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+    if (!hasAccess) {
+      throw new Error("Access denied");
+    }
+    const now = Date.now();
+    const globalId = generateGlobalId();
+    const contentHash = generateContentHash(args.question);
+    const category = normalizeCategory(args.category);
+    const additionalMetadata = args.metadata && typeof args.metadata === "object" ? args.metadata : {};
+    const nodeId = await ctx.db.insert("epistemicNodes", {
+      globalId,
+      topicId: scope.topicId,
+      projectId: scope.projectId,
+      tenantId: scope.tenantId,
+      workspaceId: scope.workspaceId,
+      nodeType: "question",
+      canonicalText: args.question,
+      contentHash,
+      status: "active",
+      epistemicLayer: "L3",
+      sourceType: args.source === "user" ? "human" : "ai_generated",
+      createdAt: now,
+      updatedAt: now,
+      createdBy: args.userId,
+      metadata: {
+        ...additionalMetadata,
+        category,
+        priority: args.priority || "medium",
+        source: args.source || "ai_suggested",
+        questionStatus: "open",
+        beliefId: args.beliefId,
+        linkedBeliefId: args.beliefId,
+        chatId: args.chatId,
+        importance: args.importance,
+        epistemicUnlock: args.epistemicUnlock
+      }
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "question",
+      entityId: String(nodeId),
+      changeType: "created",
+      changedAt: now,
+      changedBy: args.userId,
+      isAgent: false,
+      projectId: scope.projectId,
+      topicId: normalizeQuestionTopicId(scope.topicId),
+      newState: {
+        ...additionalMetadata,
+        question: args.question,
+        category,
+        priority: args.priority || "medium",
+        source: args.source || "ai_suggested",
+        beliefId: args.beliefId,
+        chatId: args.chatId,
+        importance: args.importance,
+        epistemicUnlock: args.epistemicUnlock
+      },
+      triggeringAction: "epistemicQuestions.addQuestion"
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId,
+      operation: "upsert"
+    });
+    await ctx.scheduler.runAfter(
+      0,
+      "embeddingActions:generateEpistemicNodeEmbedding",
+      {
+        nodeId,
+        projectId: scope.projectId,
+        topicId: normalizeQuestionTopicId(scope.topicId),
+        createdBy: args.userId,
+        nodeType: "question",
+        text: args.question,
+        hasAnswer: false
+      }
+    );
+    await markProjectGraphDirty(
+      ctx,
+      scope.projectId,
+      normalizeQuestionTopicId(scope.topicId)
+    );
+    return nodeId;
+  }
+});
+var createEvidenceFromScoredQuestion = internalMutation({
+  args: {
+    questionNodeId: v.id("epistemicNodes"),
+    questionText: v.string(),
+    answerText: v.string(),
+    beliefId: v.string(),
+    relatedBeliefIds: v.array(v.string()),
+    conviction: v.number(),
+    rationale: v.string(),
+    ...optionalScopeArgs,
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const questionNode = await ctx.db.get(args.questionNodeId);
+    if (!questionNode) {
+      return;
+    }
+    const qMeta = questionNode.metadata || {};
+    if (qMeta.evidenceNodeId) {
+      return;
+    }
+    const evidenceText = `Q: ${args.questionText}
+
+A: ${args.answerText}`;
+    const globalId = generateGlobalId();
+    const contentHash = `evidence:${args.questionNodeId}:scored`;
+    const evidenceNodeId = await ctx.db.insert("epistemicNodes", {
+      globalId,
+      projectId: args.projectId,
+      topicId: normalizeQuestionTopicId(args.topicId),
+      nodeType: "evidence",
+      canonicalText: evidenceText,
+      contentHash,
+      status: "active",
+      epistemicLayer: "L2",
+      sourceType: "verified",
+      // Human-scored sprint answer
+      createdAt: now,
+      updatedAt: now,
+      createdBy: args.userId,
+      metadata: {
+        kind: "observation",
+        sourceQuestionId: args.questionNodeId,
+        sprintConviction: args.conviction,
+        rationale: args.rationale,
+        origin: "sprint_question_scoring"
+      }
+    });
+    await ctx.db.patch(args.questionNodeId, {
+      metadata: {
+        ...qMeta,
+        evidenceNodeId
+      },
+      updatedAt: now
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: evidenceNodeId,
+      operation: "upsert"
+    });
+    const allBeliefIds = /* @__PURE__ */ new Set();
+    allBeliefIds.add(args.beliefId);
+    for (const id of args.relatedBeliefIds) {
+      allBeliefIds.add(id);
+    }
+    const weight = args.conviction >= 0.5 ? args.conviction : -(1 - args.conviction);
+    async function resolveBeliefNode(bId) {
+      try {
+        const node = await ctx.db.get(bId);
+        if (node?.nodeType === "belief") {
+          return node;
+        }
+      } catch {
+        return null;
+      }
+      return null;
+    }
+    for (const bId of allBeliefIds) {
+      const beliefNode = await resolveBeliefNode(bId);
+      if (!beliefNode) {
+        continue;
+      }
+      const edgeGlobalId = generateGlobalId();
+      await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+        globalId: edgeGlobalId,
+        fromGlobalId: globalId,
+        toGlobalId: beliefNode.globalId,
+        edgeType: "informs",
+        weight,
+        confidence: Math.abs(weight),
+        context: `origin=sprint_question_scoring | relation=${weight >= 0 ? "supports" : "contradicts"} | sourceQuestionId=${String(args.questionNodeId)}`,
+        createdBy: args.userId,
+        topicId: args.projectId ? String(args.projectId) : void 0,
+        fromNodeType: "evidence",
+        toNodeType: "belief",
+        fromLayer: "L2",
+        toLayer: "L3"
+      });
+    }
+    const answersEdgeGlobalId = generateGlobalId();
+    await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.createEdge, {
+      globalId: answersEdgeGlobalId,
+      fromGlobalId: globalId,
+      toGlobalId: questionNode.globalId,
+      edgeType: "derived_from",
+      weight: 1,
+      confidence: 1,
+      context: `origin=sprint_question_scoring | sourceQuestionId=${String(args.questionNodeId)}`,
+      createdBy: args.userId,
+      topicId: args.projectId ? String(args.projectId) : void 0,
+      fromNodeType: "evidence",
+      toNodeType: "question",
+      fromLayer: "L2",
+      toLayer: "L3"
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "evidence",
+      entityId: evidenceNodeId,
+      changeType: "created",
+      changedAt: now,
+      changedBy: args.userId,
+      isAgent: false,
+      projectId: args.projectId,
+      topicId: normalizeQuestionTopicId(args.topicId),
+      newState: {
+        text: evidenceText.slice(0, 200),
+        kind: "observation",
+        sourceType: "verified",
+        origin: "sprint_question_scoring",
+        linkedBeliefIds: [...allBeliefIds]
+      }
+    });
+    await markProjectGraphDirty(
+      ctx,
+      args.projectId,
+      normalizeQuestionTopicId(args.topicId)
+    );
+    return { evidenceNodeId };
+  }
+});
+var backfillScoredQuestionEvidence = internalMutation({
+  args: {
+    ...optionalScopeArgs,
+    userId: v.string(),
+    dryRun: v.optional(v.boolean())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const dryRun = args.dryRun ?? false;
+    const scope = await resolveQuestionScopeOrNull(ctx, args);
+    if (!scope) {
+      return {
+        dryRun,
+        totalQuestions: 0,
+        candidateCount: 0,
+        scheduled: 0,
+        skipped: 0,
+        candidates: []
+      };
+    }
+    const allQuestions = await getQuestionNodesForScope(ctx, scope);
+    const candidates = allQuestions.filter((n) => {
+      const meta = n.metadata || {};
+      return meta.convictionStage === "scored" && meta.answer && !meta.evidenceNodeId && (meta.linkedBeliefId || meta.beliefId);
+    });
+    if (dryRun) {
+      return {
+        dryRun: true,
+        candidateCount: candidates.length,
+        candidates: candidates.map((n) => {
+          const meta = n.metadata || {};
+          return {
+            questionId: n._id,
+            questionText: n.canonicalText?.slice(0, 80),
+            beliefId: meta.linkedBeliefId || meta.beliefId,
+            conviction: meta.conviction,
+            hasAnswer: !!meta.answer
+          };
+        })
+      };
+    }
+    let created = 0;
+    let skipped = 0;
+    for (const questionNode of candidates) {
+      const meta = questionNode.metadata || {};
+      const beliefId = meta.linkedBeliefId ?? meta.beliefId;
+      const answerText = meta.answer;
+      const conviction = meta.conviction ?? 0.5;
+      if (!beliefId || !answerText) {
+        skipped++;
+        continue;
+      }
+      await ctx.scheduler.runAfter(
+        created * 100,
+        // Stagger to avoid overwhelming Neo4j
+        internal.epistemicQuestions.createEvidenceFromScoredQuestion,
+        {
+          questionNodeId: questionNode._id,
+          questionText: questionNode.canonicalText || "",
+          answerText,
+          beliefId,
+          relatedBeliefIds: meta.relatedBeliefIds || [],
+          conviction,
+          rationale: meta.convictionRationale || "",
+          projectId: scope.projectId,
+          topicId: normalizeQuestionTopicId(scope.topicId),
+          userId: args.userId
+        }
+      );
+      created++;
+    }
+    if (created > 0) {
+      await markProjectGraphDirty(
+        ctx,
+        scope.projectId,
+        normalizeQuestionTopicId(scope.topicId)
+      );
+    }
+    return {
+      dryRun: false,
+      totalQuestions: allQuestions.length,
+      candidateCount: candidates.length,
+      scheduled: created,
+      skipped
+    };
+  }
+});
+var getForSprintCluster = query({
+  args: {
+    sprintId: v.optional(v.string()),
+    worktreeId: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const docId = args.sprintId || args.worktreeId;
+    if (!docId) return [];
+    const workflow = await resolveWorkflowBridgeDoc(ctx, docId);
+    const scopeDoc = workflow.worktree ?? workflow.sprint;
+    if (!scopeDoc) {
+      return [];
+    }
+    const scope = await resolveQuestionScopeOrNull(ctx, {
+      projectId: workflow.projectId,
+      topicId: workflow.topicId
+    });
+    const scopeId = scope ? resolveQuestionScopeId(scope) : void 0;
+    if (!scope || !scopeId) {
+      return [];
+    }
+    const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+    if (!hasAccess) {
+      return [];
+    }
+    const synthesisState = scopeDoc.synthesisState;
+    const hypothesisIds = new Set(
+      (synthesisState?.synthesizedBeliefIds || []).map(
+        (id) => String(id)
+      )
+    );
+    const rawBeliefIds = new Set(
+      (synthesisState?.originalBeliefIds || []).map(
+        (id) => String(id)
+      )
+    );
+    const clusterBeliefIds = new Set(hypothesisIds);
+    const edges = await getQuestionEdgesForScope(ctx, scope);
+    for (const edge of edges) {
+      const fromStr = String(edge.fromNodeId || "");
+      const toStr = String(edge.toNodeId || "");
+      if (hypothesisIds.has(fromStr) && !rawBeliefIds.has(toStr)) {
+        clusterBeliefIds.add(toStr);
+      }
+      if (hypothesisIds.has(toStr) && !rawBeliefIds.has(fromStr)) {
+        clusterBeliefIds.add(fromStr);
+      }
+    }
+    const questionNodes = await getQuestionNodesForScope(ctx, scope);
+    const sprintQuestionIds = new Set(
+      (workflow.worktree?.targetQuestionIds || workflow.sprint?.targetQuestionIds || []).map((id) => String(id))
+    );
+    const clusterQuestions = questionNodes.filter((q) => {
+      if (sprintQuestionIds.has(String(q._id))) {
+        return true;
+      }
+      const meta = q.metadata || {};
+      const linkedId = String(meta.linkedBeliefNodeId || "");
+      if (linkedId && clusterBeliefIds.has(linkedId)) {
+        return true;
+      }
+      return edges.some(
+        (e) => String(e.fromNodeId) === String(q._id) && clusterBeliefIds.has(String(e.toNodeId || "")) || String(e.toNodeId) === String(q._id) && clusterBeliefIds.has(String(e.fromNodeId || ""))
+      );
+    });
+    const enrichedQuestions = await Promise.all(
+      clusterQuestions.map(async (q) => {
+        const meta = q.metadata || {};
+        const linkedBeliefNodeIds = /* @__PURE__ */ new Set();
+        const primaryBeliefId = String(meta.linkedBeliefNodeId || "");
+        if (primaryBeliefId) {
+          linkedBeliefNodeIds.add(primaryBeliefId);
+        }
+        for (const edge of edges) {
+          if (String(edge.fromNodeId) === String(q._id)) {
+            linkedBeliefNodeIds.add(String(edge.toNodeId || ""));
+          }
+          if (String(edge.toNodeId) === String(q._id)) {
+            linkedBeliefNodeIds.add(String(edge.fromNodeId || ""));
+          }
+        }
+        linkedBeliefNodeIds.delete("");
+        const linkedBeliefs = (await Promise.all(
+          Array.from(linkedBeliefNodeIds).map(async (nodeId) => {
+            const node = await ctx.db.get(nodeId);
+            if (!node || node.nodeType !== "belief") {
+              return null;
+            }
+            const isHypothesis = hypothesisIds.has(nodeId);
+            const isRaw = rawBeliefIds.has(nodeId);
+            const isConditional = !isHypothesis && !isRaw && clusterBeliefIds.has(nodeId);
+            return {
+              beliefId: node._id,
+              beliefText: node.canonicalText || "",
+              isHypothesis,
+              isConditional,
+              isRaw,
+              isPrimaryTarget: isHypothesis
+            };
+          })
+        )).filter(Boolean);
+        return {
+          _id: q._id,
+          _creationTime: q._creationTime,
+          projectId: q.projectId,
+          topicId: q.topicId,
+          canonicalText: q.canonicalText,
+          question: q.canonicalText,
+          // legacy field name
+          questionType: q.questionType || meta.questionType || "general",
+          priority: meta.priority || "medium",
+          isKeyQuestion: meta.isKeyQuestion || false,
+          testType: meta.testType || "validates",
+          category: meta.category || "other",
+          status: q.status,
+          linkedBeliefs,
+          testLogic: meta.testType || "validates",
+          testRationale: meta.rationale || null,
+          beliefId: meta.linkedBeliefNodeId || null,
+          relatedBeliefIds: Array.from(linkedBeliefNodeIds),
+          // Conviction stage fields — needed by UI to show/hide action buttons
+          convictionStage: meta.convictionStage || null,
+          answer: meta.answer || null,
+          conviction: meta.conviction ?? null,
+          linkedWorktreeId: resolveLinkedWorktreeId(meta),
+          metadata: q.metadata
+        };
+      })
+    );
+    const seen = /* @__PURE__ */ new Set();
+    return enrichedQuestions.filter((q) => {
+      if (seen.has(String(q._id))) {
+        return false;
+      }
+      seen.add(String(q._id));
+      return true;
+    });
+  }
+});
+var getInConviction = query({
+  args: {
+    sprintId: v.optional(v.string()),
+    worktreeId: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const docId = args.sprintId || args.worktreeId;
+    if (!docId) return [];
+    const workflow = await resolveWorkflowBridgeDoc(ctx, docId);
+    const scopeDoc = workflow.worktree ?? workflow.sprint;
+    if (!scopeDoc) {
+      return [];
+    }
+    const scope = await resolveQuestionScopeOrNull(ctx, {
+      projectId: workflow.projectId,
+      topicId: workflow.topicId
+    });
+    const scopeId = scope ? resolveQuestionScopeId(scope) : void 0;
+    if (!scope || !scopeId) {
+      return [];
+    }
+    const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+    if (!hasAccess) {
+      return [];
+    }
+    const allQuestions = await getQuestionNodesForScope(ctx, scope);
+    const convictionQuestions = allQuestions.filter((q) => {
+      const meta = q.metadata || {};
+      return meta.convictionStage === "in_conviction" || meta.convictionStage === "scored";
+    });
+    const sprintBeliefIds = /* @__PURE__ */ new Set([
+      ...(scopeDoc.synthesisState?.synthesizedBeliefIds || []).map(
+        String
+      ),
+      ...(workflow.worktree?.targetBeliefIds || workflow.sprint?.targetBeliefIds || []).map(String)
+    ]);
+    const sprintQuestions = convictionQuestions.filter((q) => {
+      const meta = q.metadata || {};
+      if (questionMatchesWorkflowLink(meta, workflow)) {
+        return true;
+      }
+      if (meta.linkedBeliefNodeId && sprintBeliefIds.has(String(meta.linkedBeliefNodeId))) {
+        return true;
+      }
+      if (meta.linkedBeliefId && sprintBeliefIds.has(String(meta.linkedBeliefId))) {
+        return true;
+      }
+      if (meta.beliefId && sprintBeliefIds.has(String(meta.beliefId))) {
+        return true;
+      }
+      const relatedIds = meta.relatedBeliefIds || [];
+      if (relatedIds.some((id) => sprintBeliefIds.has(String(id)))) {
+        return true;
+      }
+      return false;
+    });
+    const questionsWithDetails = await Promise.all(
+      sprintQuestions.map(async (q) => {
+        const meta = q.metadata || {};
+        const evidenceLinks = await ctx.db.query("questionEvidenceLinks").withIndex("by_questionId", (qb) => qb.eq("questionId", q._id)).collect();
+        const evidenceWithDetails = await Promise.all(
+          evidenceLinks.map(async (link) => {
+            const insight = await ctx.db.get(link.insightId);
+            const insightMeta = insight?.metadata || {};
+            const canonicalText = insight?.canonicalText;
+            const legacyText = insight?.text;
+            const contentText = insight?.content;
+            const titleText = insight?.title;
+            const snippetText = insightMeta.snippet;
+            return {
+              ...link,
+              insightText: typeof canonicalText === "string" && canonicalText.trim() || typeof legacyText === "string" && legacyText.trim() || typeof contentText === "string" && contentText.trim() || typeof titleText === "string" && titleText.trim() || typeof snippetText === "string" && snippetText.trim() || "",
+              insightSource: insight?.sourceType || "unknown"
+            };
+          })
+        );
+        const beliefIds = [];
+        const relatedIds = meta.relatedBeliefIds || [];
+        if (meta.linkedBeliefNodeId) {
+          beliefIds.push(String(meta.linkedBeliefNodeId));
+        }
+        if (meta.linkedBeliefId) {
+          beliefIds.push(String(meta.linkedBeliefId));
+        }
+        if (meta.beliefId) {
+          beliefIds.push(String(meta.beliefId));
+        }
+        for (const id of relatedIds) {
+          if (!beliefIds.includes(String(id))) {
+            beliefIds.push(String(id));
+          }
+        }
+        const beliefsWithDetails = await Promise.all(
+          beliefIds.map(async (beliefId) => {
+            try {
+              const node = await ctx.db.get(beliefId);
+              if (node && node.nodeType === "belief") {
+                return {
+                  _id: node._id,
+                  belief: node.canonicalText || "",
+                  confidence: node.metadata?.confidence,
+                  pillar: node.metadata?.category,
+                  beliefType: node.status,
+                  dependsOnCount: 0,
+                  cascadesToCount: 0,
+                  exclusiveWithCount: 0
+                };
+              }
+            } catch {
+            }
+            return null;
+          })
+        );
+        return {
+          _id: q._id,
+          _creationTime: q._creationTime,
+          projectId: q.projectId,
+          question: q.canonicalText,
+          canonicalText: q.canonicalText,
+          category: meta.category || "other",
+          priority: meta.priority || "medium",
+          status: meta.questionStatus || q.status,
+          questionType: q.questionType || meta.questionType || "general",
+          testType: meta.testType || void 0,
+          importance: meta.importance || void 0,
+          isKeyQuestion: meta.isKeyQuestion || false,
+          conviction: meta.conviction,
+          convictionStage: meta.convictionStage,
+          convictionRationale: meta.convictionRationale,
+          convictionAdvancedAt: meta.convictionAdvancedAt,
+          convictionAdvancedBy: meta.convictionAdvancedBy,
+          convictionUpdatedAt: meta.convictionUpdatedAt,
+          convictionUpdatedBy: meta.convictionUpdatedBy,
+          answer: meta.answer,
+          answerStatus: meta.answerStatus,
+          answerCompleteness: meta.answerCompleteness,
+          whatWeNeed: meta.whatWeNeed,
+          linkedWorktreeId: resolveLinkedWorktreeId(meta) || void 0,
+          beliefId: meta.linkedBeliefNodeId || meta.beliefId || null,
+          linkedBeliefId: meta.linkedBeliefNodeId || meta.linkedBeliefId,
+          relatedBeliefIds: relatedIds,
+          evidenceCount: evidenceWithDetails.length,
+          evidence: evidenceWithDetails,
+          testedBeliefs: beliefsWithDetails.filter(Boolean),
+          createdAt: q.createdAt,
+          createdBy: q.createdBy,
+          updatedAt: q.updatedAt,
+          metadata: q.metadata
+        };
+      })
+    );
+    return questionsWithDetails.sort((a, b) => {
+      if (a.convictionStage === "in_conviction" && b.convictionStage === "scored") {
+        return -1;
+      }
+      if (a.convictionStage === "scored" && b.convictionStage === "in_conviction") {
+        return 1;
+      }
+      return (a.importance || 5) - (b.importance || 5);
+    });
+  }
+});
+var advanceToConviction = mutation({
+  args: {
+    questionId: v.id("epistemicNodes"),
+    userId: v.string(),
+    sprintId: v.optional(v.string()),
+    worktreeId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = await ctx.db.get(args.questionId);
+    if (!node || node.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    const meta = node.metadata || {};
+    if (meta.convictionStage === "in_conviction" || meta.convictionStage === "scored") {
+      throw new Error("Question is already in conviction stage");
+    }
+    const now = Date.now();
+    await ctx.db.patch(args.questionId, {
+      updatedAt: now,
+      metadata: {
+        ...meta,
+        convictionStage: "in_conviction",
+        convictionAdvancedAt: now,
+        convictionAdvancedBy: args.userId,
+        ...buildLinkedWorktreeMetadata(args.worktreeId ?? args.sprintId)
+      }
+    });
+    try {
+      await ctx.db.insert("epistemicAudit", {
+        entityType: "question",
+        entityId: args.questionId,
+        changeType: "status_changed",
+        changedAt: now,
+        changedBy: args.userId,
+        isAgent: false,
+        projectId: node.projectId,
+        previousState: {
+          convictionStage: meta.convictionStage || "researching"
+        },
+        newState: { convictionStage: "in_conviction" },
+        triggeringAction: "question_advanced_to_conviction"
+      });
+    } catch (e) {
+      console.error("[EpistemicAudit] Failed to log advanceToConviction:", e);
+    }
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+    return {
+      questionId: args.questionId,
+      convictionStage: "in_conviction",
+      advancedAt: now
+    };
+  }
+});
+var updateConviction = mutation({
+  args: {
+    questionId: v.id("epistemicNodes"),
+    conviction: v.optional(v.number()),
+    answerCompleteness: v.optional(
+      v.union(
+        v.literal("unanswered"),
+        v.literal("partial"),
+        v.literal("sufficient"),
+        v.literal("comprehensive")
+      )
+    ),
+    convictionRationale: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = await ctx.db.get(args.questionId);
+    if (!node || node.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    const now = Date.now();
+    const meta = node.metadata || {};
+    const updates = { ...meta };
+    if (args.conviction !== void 0) {
+      updates.conviction = Math.max(0, Math.min(1, args.conviction));
+    }
+    if (args.answerCompleteness !== void 0) {
+      updates.answerCompleteness = args.answerCompleteness;
+    }
+    if (args.convictionRationale !== void 0) {
+      updates.convictionRationale = args.convictionRationale;
+    }
+    updates.convictionUpdatedAt = now;
+    updates.convictionUpdatedBy = args.userId;
+    await ctx.db.patch(args.questionId, {
+      updatedAt: now,
+      metadata: updates
+    });
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+    return {
+      questionId: args.questionId,
+      conviction: updates.conviction ?? meta.conviction,
+      answerCompleteness: updates.answerCompleteness ?? meta.answerCompleteness
+    };
+  }
+});
+var finalizeConviction = mutation({
+  args: {
+    questionId: v.id("epistemicNodes"),
+    conviction: v.number(),
+    answer: v.string(),
+    convictionRationale: v.optional(v.string()),
+    userId: v.string(),
+    answerCompleteness: v.optional(
+      v.union(
+        v.literal("unanswered"),
+        v.literal("partial"),
+        v.literal("sufficient"),
+        v.literal("comprehensive"),
+        v.literal("unanswerable")
+      )
+    ),
+    whatWeNeed: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = await ctx.db.get(args.questionId);
+    if (!node || node.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    const now = Date.now();
+    const clampedConviction = Math.max(0, Math.min(1, args.conviction));
+    const isUnanswerable = args.answerCompleteness === "unanswerable";
+    const meta = node.metadata || {};
+    let completeness = args.answerCompleteness;
+    if (!completeness) {
+      completeness = clampedConviction >= 0.8 ? "comprehensive" : clampedConviction >= 0.6 ? "sufficient" : clampedConviction >= 0.3 ? "partial" : "unanswered";
+    }
+    await ctx.db.patch(args.questionId, {
+      updatedAt: now,
+      metadata: {
+        ...meta,
+        convictionStage: "scored",
+        conviction: clampedConviction,
+        convictionRationale: args.convictionRationale,
+        convictionUpdatedAt: now,
+        convictionUpdatedBy: args.userId,
+        answer: args.answer,
+        answerStatus: "final",
+        questionStatus: isUnanswerable ? "blocked" : "answered",
+        answeredAt: now,
+        answeredBy: args.userId,
+        answerCompleteness: completeness,
+        whatWeNeed: args.whatWeNeed
+      }
+    });
+    try {
+      await ctx.db.insert("epistemicAudit", {
+        entityType: "question",
+        entityId: args.questionId,
+        changeType: "status_changed",
+        changedAt: now,
+        changedBy: args.userId,
+        isAgent: false,
+        projectId: node.projectId,
+        previousState: {
+          convictionStage: meta.convictionStage || "in_conviction"
+        },
+        newState: {
+          convictionStage: "scored",
+          conviction: clampedConviction
+        },
+        triggeringAction: "question_conviction_finalized"
+      });
+    } catch (e) {
+      console.error("[EpistemicAudit] Failed to log finalizeConviction:", e);
+    }
+    if (node.projectId || node.topicId) {
+      const beliefId = meta.linkedBeliefNodeId || meta.linkedBeliefId || meta.beliefId;
+      if (beliefId) {
+        try {
+          await ctx.scheduler.runAfter(
+            0,
+            internal.epistemicQuestions.createEvidenceFromScoredQuestion,
+            {
+              questionNodeId: args.questionId,
+              questionText: node.canonicalText || "",
+              answerText: args.answer,
+              beliefId,
+              relatedBeliefIds: meta.relatedBeliefIds || [],
+              conviction: clampedConviction,
+              rationale: args.convictionRationale || "",
+              projectId: node.projectId,
+              topicId: normalizeQuestionTopicId(node.topicId),
+              userId: args.userId
+            }
+          );
+        } catch (e) {
+          console.error(
+            "[finalizeConviction] Failed to schedule evidence creation:",
+            e
+          );
+        }
+      }
+    }
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: args.questionId,
+      operation: "upsert"
+    });
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+    return {
+      questionId: args.questionId,
+      convictionStage: "scored",
+      conviction: clampedConviction
+    };
+  }
+});
+var getByBeliefWithAccess = query({
+  args: {
+    beliefId: v.string(),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    let beliefNode = null;
+    try {
+      beliefNode = await ctx.db.get(args.beliefId);
+    } catch {
+      try {
+        beliefNode = await ctx.db.get(args.beliefId);
+      } catch {
+        return [];
+      }
+    }
+    if (!beliefNode) {
+      return [];
+    }
+    const scope = await resolveQuestionScopeOrNull(ctx, {
+      projectId: beliefNode.projectId,
+      topicId: normalizeQuestionTopicId(beliefNode.topicId)
+    });
+    const scopeId = scope ? resolveQuestionScopeId(scope) : void 0;
+    if (!scope || !scopeId) {
+      return [];
+    }
+    const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+    if (!hasAccess) {
+      return [];
+    }
+    const questionNodes = await getQuestionNodesForScope(ctx, scope);
+    const beliefIdStr = String(args.beliefId);
+    return questionNodes.filter((q) => {
+      const meta = q.metadata || {};
+      if (String(meta.linkedBeliefNodeId || "") === beliefIdStr) {
+        return true;
+      }
+      if (String(meta.linkedBeliefId || "") === beliefIdStr) {
+        return true;
+      }
+      if (String(meta.beliefId || "") === beliefIdStr) {
+        return true;
+      }
+      const relatedIds = meta.relatedBeliefIds || [];
+      if (relatedIds.some((id) => String(id) === beliefIdStr)) {
+        return true;
+      }
+      return false;
+    });
+  }
+});
+var updateQuestion = mutation({
+  args: {
+    questionId: v.id("epistemicNodes"),
+    question: v.optional(v.string()),
+    category: v.optional(
+      v.union(
+        v.literal("market"),
+        v.literal("competition"),
+        v.literal("product"),
+        v.literal("team"),
+        v.literal("financials"),
+        v.literal("financial"),
+        v.literal("regulatory"),
+        v.literal("timing"),
+        v.literal("customer"),
+        v.literal("technology"),
+        v.literal("distribution"),
+        v.literal("strategic"),
+        v.literal("other")
+      )
+    ),
+    priority: v.optional(
+      v.union(v.literal("high"), v.literal("medium"), v.literal("low"))
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = await ctx.db.get(args.questionId);
+    if (!node || node.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    const now = Date.now();
+    const meta = node.metadata || {};
+    const metaUpdates = { ...meta };
+    if (args.category) {
+      const category = args.category === "financial" ? "financials" : args.category;
+      metaUpdates.category = category;
+    }
+    if (args.priority) {
+      metaUpdates.priority = args.priority;
+    }
+    const patchData = {
+      updatedAt: now,
+      metadata: metaUpdates
+    };
+    if (args.question !== void 0) {
+      patchData.canonicalText = args.question;
+      patchData.contentHash = generateContentHash(args.question);
+      if (node.sourceType === "ai_generated") {
+        patchData.sourceType = "human";
+      }
+    }
+    await ctx.db.patch(args.questionId, patchData);
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: args.questionId,
+      operation: "upsert"
+    });
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+  }
+});
+var linkToBelief = mutation({
+  args: {
+    questionId: v.id("epistemicNodes"),
+    beliefId: v.string(),
+    // Accept string for backward compat
+    userId: v.string(),
+    testType: v.optional(
+      v.union(
+        v.literal("validates"),
+        v.literal("invalidates"),
+        v.literal("clarifies")
+      )
+    ),
+    answerImpact: v.optional(
+      v.object({
+        ifYes: v.string(),
+        ifNo: v.string()
+      })
+    ),
+    isPrimaryBelief: v.optional(v.boolean())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const questionNode = await ctx.db.get(args.questionId);
+    if (!questionNode || questionNode.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    const questionScopeId = resolveQuestionScopeId({
+      projectId: questionNode.projectId,
+      topicId: normalizeQuestionTopicId(questionNode.topicId)
+    });
+    if (questionScopeId) {
+      const hasAccess = await checkScopeAccess(
+        ctx,
+        questionScopeId,
+        args.userId
+      );
+      if (!hasAccess) {
+        throw new Error("Access denied");
+      }
+    }
+    let beliefNode = null;
+    try {
+      beliefNode = await ctx.db.get(args.beliefId);
+    } catch {
+      try {
+        beliefNode = await ctx.db.get(args.beliefId);
+      } catch {
+        throw new Error("Belief not found");
+      }
+    }
+    if (!beliefNode) {
+      throw new Error("Belief not found");
+    }
+    const now = Date.now();
+    const meta = questionNode.metadata || {};
+    const currentBeliefs = meta.relatedBeliefIds || [];
+    const beliefIdStr = String(args.beliefId);
+    const newRelated = currentBeliefs.includes(beliefIdStr) ? currentBeliefs : [...currentBeliefs, beliefIdStr];
+    const metaUpdates = {
+      ...meta,
+      relatedBeliefIds: newRelated
+    };
+    if (args.isPrimaryBelief || args.testType) {
+      metaUpdates.linkedBeliefNodeId = args.beliefId;
+      metaUpdates.linkedBeliefId = args.beliefId;
+      metaUpdates.questionType = "belief_test";
+      if (args.testType) {
+        metaUpdates.testType = args.testType;
+      }
+      if (args.answerImpact) {
+        metaUpdates.answerImpact = args.answerImpact;
+      }
+    }
+    await ctx.db.patch(args.questionId, {
+      updatedAt: now,
+      metadata: metaUpdates
+    });
+    try {
+      const beliefGlobalId = beliefNode.globalId;
+      if (beliefGlobalId && questionNode.globalId) {
+        await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+          nodeId: args.questionId,
+          operation: "upsert"
+        });
+        await ctx.scheduler.runAfter(100, internal.neo4jSync.syncNodeToNeo4j, {
+          nodeId: args.beliefId,
+          operation: "upsert"
+        });
+        const edgeGlobalId = buildTestsEdgeGlobalId(
+          questionNode.globalId,
+          beliefGlobalId
+        );
+        await ctx.scheduler.runAfter(250, internal.neo4jEdgeAPI.createEdge, {
+          globalId: edgeGlobalId,
+          fromGlobalId: questionNode.globalId,
+          toGlobalId: beliefGlobalId,
+          edgeType: "tests",
+          context: args.testType || "tests",
+          topicId: questionNode.projectId ? String(questionNode.projectId) : void 0,
+          createdBy: args.userId,
+          fromNodeType: "question",
+          toNodeType: "belief",
+          fromLayer: "L3",
+          toLayer: "L3"
+        });
+      }
+    } catch (e) {
+      console.error("[linkToBelief] Failed to create tests edge:", e);
+    }
+    await markProjectGraphDirty(
+      ctx,
+      questionNode.projectId,
+      questionNode.topicId
+    );
+  }
+});
+var linkToInsight = mutation({
+  args: {
+    questionId: v.id("epistemicNodes"),
+    insightId: v.id("epistemicNodes"),
+    userId: v.string(),
+    sprintId: v.optional(v.string()),
+    worktreeId: v.optional(v.string()),
+    relevance: v.optional(v.number()),
+    rationale: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const questionNode = await ctx.db.get(args.questionId);
+    if (!questionNode || questionNode.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    const insight = await ctx.db.get(args.insightId);
+    if (!insight) {
+      throw new Error("Insight not found");
+    }
+    const questionScopeId = resolveQuestionScopeId({
+      projectId: questionNode.projectId,
+      topicId: normalizeQuestionTopicId(questionNode.topicId)
+    });
+    if (questionScopeId) {
+      const hasAccess = await checkScopeAccess(
+        ctx,
+        questionScopeId,
+        args.userId
+      );
+      if (!hasAccess) {
+        throw new Error("Access denied");
+      }
+    }
+    const now = Date.now();
+    const meta = questionNode.metadata || {};
+    const currentInsights = meta.relatedInsightIds || [];
+    const insightIdStr = String(args.insightId);
+    if (!currentInsights.includes(insightIdStr)) {
+      await ctx.db.patch(args.questionId, {
+        updatedAt: now,
+        metadata: {
+          ...meta,
+          relatedInsightIds: [...currentInsights, insightIdStr]
+        }
+      });
+      try {
+        const existingLinks = await ctx.db.query("questionEvidenceLinks").withIndex(
+          "by_questionId",
+          (q) => q.eq("questionId", args.questionId)
+        ).collect();
+        const duplicate = existingLinks.find(
+          (link) => String(link.insightId) === String(args.insightId)
+        );
+        if (!duplicate) {
+          await ctx.db.insert("questionEvidenceLinks", {
+            questionId: args.questionId,
+            insightId: args.insightId,
+            helpsAnswer: true,
+            relevance: args.relevance ?? 0.7,
+            rationale: args.rationale || "Linked from research results",
+            createdBy: args.userId,
+            createdAt: now
+          });
+        }
+      } catch (e) {
+        console.error(
+          "[linkToInsight] Failed to create questionEvidenceLink:",
+          e
+        );
+      }
+    }
+    await markProjectGraphDirty(
+      ctx,
+      questionNode.projectId,
+      questionNode.topicId
+    );
+  }
+});
+var unlinkInsight = mutation({
+  args: {
+    questionId: v.id("epistemicNodes"),
+    insightId: v.id("epistemicNodes"),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const questionNode = await ctx.db.get(args.questionId);
+    if (!questionNode || questionNode.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    const questionScopeId = resolveQuestionScopeId({
+      projectId: questionNode.projectId,
+      topicId: normalizeQuestionTopicId(questionNode.topicId)
+    });
+    if (questionScopeId) {
+      const hasAccess = await checkScopeAccess(
+        ctx,
+        questionScopeId,
+        args.userId
+      );
+      if (!hasAccess) {
+        throw new Error("Access denied");
+      }
+    }
+    const now = Date.now();
+    const meta = questionNode.metadata || {};
+    const currentInsights = meta.relatedInsightIds || [];
+    const newInsights = currentInsights.filter(
+      (id) => String(id) !== String(args.insightId)
+    );
+    await ctx.db.patch(args.questionId, {
+      updatedAt: now,
+      metadata: {
+        ...meta,
+        relatedInsightIds: newInsights
+      }
+    });
+    try {
+      const links = await ctx.db.query("questionEvidenceLinks").withIndex(
+        "by_questionId",
+        (q) => q.eq("questionId", args.questionId)
+      ).collect();
+      for (const link of links) {
+        if (String(link.insightId) === String(args.insightId)) {
+          await ctx.db.delete(link._id);
+        }
+      }
+    } catch (e) {
+      console.error(
+        "[unlinkInsight] Failed to remove questionEvidenceLink:",
+        e
+      );
+    }
+    try {
+      const evidenceNode = await ctx.db.get(args.insightId);
+      if (evidenceNode && evidenceNode.nodeType === "evidence") {
+        const edges = await ctx.db.query("epistemicEdges").withIndex(
+          "by_from_to",
+          (q) => q.eq("fromNodeId", evidenceNode._id).eq("toNodeId", args.questionId)
+        ).collect();
+        for (const edge of edges) {
+          if (edge.edgeType === "derived_from") {
+            await ctx.scheduler.runAfter(0, internal.neo4jEdgeAPI.deleteEdge, {
+              globalId: edge.globalId
+            });
+            await ctx.db.delete(edge._id);
+          }
+        }
+      }
+    } catch (e) {
+      console.error("[unlinkInsight] Failed to remove edge:", e);
+    }
+    await markProjectGraphDirty(
+      ctx,
+      questionNode.projectId,
+      questionNode.topicId
+    );
+  }
+});
+var list = query({
+  args: {
+    ...optionalScopeArgs,
+    userId: v.string(),
+    status: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveQuestionScopeOrNull(ctx, args);
+    if (!scope) {
+      return [];
+    }
+    const scopeId = resolveQuestionScopeId(scope);
+    if (!scopeId) {
+      return [];
+    }
+    const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+    if (!hasAccess) {
+      return [];
+    }
+    const nodes = await getQuestionNodesForScope(ctx, scope);
+    const filtered = args.status ? nodes.filter(
+      (node) => matchesRequestedQuestionStatus(node, args.status)
+    ) : nodes.filter(isActiveQuestionNode);
+    return filtered.map(flattenInternalQuestionNode);
+  }
+});
+var getByPillar = query({
+  args: {
+    ...optionalScopeArgs,
+    pillar: v.string(),
+    includeAnswered: v.optional(v.boolean()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveQuestionScopeOrNull(ctx, args);
+    if (!scope) {
+      return { questions: [], beliefs: [] };
+    }
+    const scopeId = resolveQuestionScopeId(scope);
+    if (!scopeId) {
+      return { questions: [], beliefs: [] };
+    }
+    const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+    if (!hasAccess) {
+      return { questions: [], beliefs: [] };
+    }
+    const allBeliefNodes = await ctx.db.query("epistemicNodes").withIndex(
+      scope.topicId ? "by_topic_type" : "by_project_type",
+      (q) => scope.topicId ? q.eq("topicId", scope.topicId).eq("nodeType", "belief") : q.eq("projectId", scope.projectId).eq("nodeType", "belief")
+    ).collect();
+    const beliefs = allBeliefNodes.filter((n) => {
+      const meta = n.metadata || {};
+      return (meta.category === args.pillar || meta.topic === args.pillar || meta.pillar === args.pillar) && n.status !== "archived";
+    });
+    if (beliefs.length === 0) {
+      return { questions: [], beliefs: [] };
+    }
+    const beliefIds = new Set(beliefs.map((b) => String(b._id)));
+    const beliefMap = new Map(
+      beliefs.map((b) => [String(b._id), b.canonicalText || ""])
+    );
+    const questionNodes = await getQuestionNodesForScope(ctx, scope);
+    const pillarQuestions = questionNodes.filter((q) => {
+      const meta = q.metadata || {};
+      const linkedId = String(
+        meta.linkedBeliefNodeId || meta.linkedBeliefId || meta.beliefId || ""
+      );
+      if (linkedId && beliefIds.has(linkedId)) {
+        return true;
+      }
+      const relatedIds = meta.relatedBeliefIds || [];
+      return relatedIds.some((id) => beliefIds.has(String(id)));
+    });
+    const includeAnswered = args.includeAnswered ?? true;
+    const filteredQuestions = includeAnswered ? pillarQuestions : pillarQuestions.filter((q) => {
+      const meta = q.metadata || {};
+      return meta.questionStatus !== "answered";
+    });
+    const enrichedQuestions = filteredQuestions.map((q) => {
+      const meta = q.metadata || {};
+      const linkedId = String(
+        meta.linkedBeliefNodeId || meta.linkedBeliefId || meta.beliefId || ""
+      );
+      return {
+        _id: q._id,
+        _creationTime: q._creationTime,
+        projectId: q.projectId,
+        question: q.canonicalText,
+        canonicalText: q.canonicalText,
+        category: meta.category || "other",
+        priority: meta.priority || "medium",
+        status: meta.questionStatus || q.status,
+        questionType: q.questionType || meta.questionType || "general",
+        beliefId: linkedId || void 0,
+        beliefText: linkedId ? beliefMap.get(linkedId) : void 0,
+        createdAt: q.createdAt,
+        createdBy: q.createdBy,
+        updatedAt: q.updatedAt
+      };
+    });
+    const priorityOrder = {
+      high: 0,
+      medium: 1,
+      low: 2
+    };
+    enrichedQuestions.sort((a, b) => {
+      const aPriority = priorityOrder[a.priority || "medium"] ?? 1;
+      const bPriority = priorityOrder[b.priority || "medium"] ?? 1;
+      if (aPriority !== bPriority) {
+        return aPriority - bPriority;
+      }
+      return (b.createdAt || 0) - (a.createdAt || 0);
+    });
+    return {
+      questions: enrichedQuestions,
+      beliefs: beliefs.map((b) => ({
+        _id: b._id,
+        belief: b.canonicalText,
+        pillar: b.metadata?.category || b.metadata?.pillar,
+        confidence: b.metadata?.confidence
+      }))
+    };
+  }
+});
+var consolidate = mutation({
+  args: {
+    ...optionalScopeArgs,
+    questionIds: v.array(v.string()),
+    // Accept string[] for backward compat
+    consolidatedQuestion: v.string(),
+    consolidationRationale: v.optional(v.string()),
+    linkedBeliefIds: v.optional(v.array(v.string())),
+    priority: v.optional(
+      v.union(v.literal("high"), v.literal("medium"), v.literal("low"))
+    ),
+    sprintId: v.optional(v.string()),
+    consolidatedBy: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveTopicProjectScope(ctx, {
+      projectId: args.projectId,
+      topicId: args.topicId
+    });
+    const scopeId = resolveQuestionScopeId(scope);
+    if (!scopeId) {
+      return [];
+    }
+    const hasAccess = await checkScopeAccess(ctx, scopeId, args.consolidatedBy);
+    if (!hasAccess) {
+      throw new Error("Access denied");
+    }
+    if (args.questionIds.length < 2) {
+      throw new Error("At least 2 questions required for consolidation");
+    }
+    const originalQuestions = await Promise.all(
+      args.questionIds.map(async (qid) => {
+        try {
+          return await ctx.db.get(qid);
+        } catch {
+          return null;
+        }
+      })
+    );
+    const validQuestions = originalQuestions.filter((q) => {
+      if (!q || q.nodeType !== "question") {
+        return false;
+      }
+      if (scope.topicId) {
+        return String(q.topicId) === String(scope.topicId) || !q.topicId && scope.projectId !== void 0 && String(q.projectId) === String(scope.projectId);
+      }
+      return String(q.projectId) === String(scope.projectId);
+    });
+    if (validQuestions.length !== args.questionIds.length) {
+      throw new Error(
+        "Some questions not found or do not belong to this topic scope"
+      );
+    }
+    const priorityOrder = {
+      high: 0,
+      medium: 1,
+      low: 2
+    };
+    let bestPriority = args.priority;
+    if (!bestPriority) {
+      let bestScore = 2;
+      for (const q of validQuestions) {
+        const meta = q?.metadata || {};
+        const score = priorityOrder[meta.priority || "medium"] ?? 1;
+        if (score < bestScore) {
+          bestScore = score;
+          bestPriority = meta.priority || "medium";
+        }
+      }
+    }
+    const linkedBeliefSet = /* @__PURE__ */ new Set();
+    if (args.linkedBeliefIds) {
+      for (const bid of args.linkedBeliefIds) {
+        linkedBeliefSet.add(String(bid));
+      }
+    } else {
+      for (const q of validQuestions) {
+        const meta = q?.metadata || {};
+        if (meta.linkedBeliefNodeId) {
+          linkedBeliefSet.add(String(meta.linkedBeliefNodeId));
+        }
+        if (meta.linkedBeliefId) {
+          linkedBeliefSet.add(String(meta.linkedBeliefId));
+        }
+      }
+    }
+    let category = "other";
+    if (linkedBeliefSet.size > 0) {
+      const firstBeliefId = Array.from(linkedBeliefSet)[0];
+      try {
+        const belief = await ctx.db.get(firstBeliefId);
+        if (belief) {
+          const bMeta = belief.metadata || {};
+          category = bMeta.category || bMeta.pillar || "other";
+        }
+      } catch {
+      }
+    }
+    const now = Date.now();
+    const globalId = generateGlobalId();
+    const contentHash = generateContentHash(args.consolidatedQuestion);
+    const newNodeId = await ctx.db.insert("epistemicNodes", {
+      globalId,
+      projectId: scope.projectId,
+      topicId: scope.topicId,
+      nodeType: "question",
+      canonicalText: args.consolidatedQuestion,
+      contentHash,
+      status: "active",
+      epistemicLayer: "L3",
+      sourceType: "human",
+      createdAt: now,
+      updatedAt: now,
+      createdBy: args.consolidatedBy,
+      metadata: {
+        category,
+        priority: bestPriority || "medium",
+        source: "consolidated",
+        questionStatus: "open",
+        linkedBeliefNodeId: linkedBeliefSet.size > 0 ? Array.from(linkedBeliefSet)[0] : void 0,
+        consolidationMetadata: {
+          originalQuestionIds: args.questionIds,
+          rationale: args.consolidationRationale,
+          consolidatedAt: now,
+          consolidatedBy: args.consolidatedBy
+        }
+      }
+    });
+    for (const qid of args.questionIds) {
+      try {
+        const node = await ctx.db.get(qid);
+        if (node) {
+          const meta = node.metadata || {};
+          await ctx.db.patch(qid, {
+            status: "archived",
+            updatedAt: now,
+            metadata: {
+              ...meta,
+              questionStatus: "archived",
+              archivedAt: now,
+              archivedReason: `Consolidated into question ${newNodeId}`,
+              consolidatedIntoId: newNodeId
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: newNodeId,
+      operation: "upsert"
+    });
+    await markProjectGraphDirty(
+      ctx,
+      scope.projectId,
+      normalizeQuestionTopicId(scope.topicId)
+    );
+    return {
+      newQuestionId: newNodeId,
+      archivedCount: args.questionIds.length,
+      linkedBeliefs: Array.from(linkedBeliefSet)
+    };
+  }
+});
+var deleteQuestion = mutation({
+  args: {
+    questionId: v.id("epistemicNodes"),
+    userId: v.string(),
+    runtimeToolName: v.optional(v.string()),
+    runtimePackKey: v.optional(v.string()),
+    runtimePackInstallScope: v.optional(
+      v.union(v.literal("tenant"), v.literal("workspace"))
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = await ctx.db.get(args.questionId);
+    if (!node || node.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    assertTenantPackWorkspaceMutationAllowed({
+      runtime: resolveRuntimePackMutationContext(args),
+      target: await resolveNodeScopeForWorkspaceIsolation(ctx, node),
+      mutationName: "epistemicQuestions.deleteQuestion"
+    });
+    const now = Date.now();
+    const meta = node.metadata || {};
+    await ctx.db.patch(args.questionId, {
+      status: "archived",
+      updatedAt: now,
+      metadata: {
+        ...meta,
+        questionStatus: "archived",
+        archivedAt: now,
+        archivedBy: args.userId
+      }
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "question",
+      entityId: args.questionId,
+      changeType: "status_changed",
+      changedAt: now,
+      changedBy: args.userId,
+      isAgent: false,
+      projectId: node.projectId,
+      previousState: {
+        status: meta.questionStatus || node.status
+      },
+      newState: { status: "archived" }
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: args.questionId,
+      operation: "upsert"
+    });
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+  }
+});
+var markAnsweredWithArtifact = mutation({
+  args: {
+    questionId: v.id("epistemicNodes"),
+    artifactId: v.id("finalArtifacts"),
+    answer: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = await ctx.db.get(args.questionId);
+    if (!node || node.nodeType !== "question") {
+      throw new Error("Question not found");
+    }
+    const artifact = await resolveGraphPrimitivesAppResolvers().getFinalArtifact(ctx, args.artifactId);
+    if (!artifact) {
+      throw new Error("Artifact not found");
+    }
+    const scopeId = resolveQuestionScopeId({
+      projectId: node.projectId,
+      topicId: normalizeQuestionTopicId(node.topicId)
+    });
+    if (scopeId) {
+      const hasAccess = await checkScopeAccess(ctx, scopeId, args.userId);
+      if (!hasAccess) {
+        throw new Error("Access denied");
+      }
+    }
+    const now = Date.now();
+    const meta = node.metadata || {};
+    await ctx.db.patch(args.questionId, {
+      updatedAt: now,
+      metadata: {
+        ...meta,
+        questionStatus: "answered",
+        answeringArtifactId: args.artifactId,
+        answer: args.answer,
+        answeredAt: now,
+        answeredBy: args.userId
+      }
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: args.questionId,
+      operation: "upsert"
+    });
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+  }
+});
+var getQuestionClusterPositions = query({
+  args: {
+    ...optionalScopeArgs,
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    let scope = null;
+    try {
+      scope = await resolveTopicProjectScope(ctx, {
+        projectId: args.projectId,
+        topicId: args.topicId
+      });
+    } catch {
+      return {
+        positions: {},
+        counts: {
+          cluster: 0,
+          sprintLinked: 0,
+          baseline: 0,
+          total: 0
+        }
+      };
+    }
+    const questionNodes = await ctx.db.query("epistemicNodes").withIndex(
+      scope.topicId ? "by_topic_type" : "by_project_type",
+      (q) => scope?.topicId ? q.eq("topicId", scope.topicId).eq("nodeType", "question") : q.eq("projectId", scope?.projectId).eq("nodeType", "question")
+    ).collect();
+    const activeQuestionNodes = questionNodes.filter(isActiveQuestionNode);
+    const positions = {};
+    let clusterCount = 0;
+    let sprintLinkedCount = 0;
+    let baselineCount = 0;
+    for (const question of activeQuestionNodes) {
+      const id = question._id.toString();
+      const meta = question.metadata || {};
+      const questionType2 = typeof question.questionType === "string" ? question.questionType : typeof meta.questionType === "string" ? meta.questionType : void 0;
+      if (questionType2 === "belief_test" || meta.testType) {
+        positions[id] = "cluster";
+        clusterCount++;
+      } else if (resolveLinkedWorktreeId(meta)) {
+        positions[id] = "sprint_linked";
+        sprintLinkedCount++;
+      } else {
+        positions[id] = "baseline";
+        baselineCount++;
+      }
+    }
+    return {
+      positions,
+      counts: {
+        cluster: clusterCount,
+        sprintLinked: sprintLinkedCount,
+        baseline: baselineCount,
+        total: activeQuestionNodes.length
+      }
+    };
+  }
+});
+
+export { addQuestion, advanceToConviction, backfillScoredQuestionEvidence, consolidate, create, createBatch, createEvidenceFromScoredQuestion, deleteQuestion, finalizeConviction, flattenQuestionNode, getByBeliefWithAccess, getByCategory, getById, getByPillar, getByProject, getByTopic, getForBelief, getForSprintCluster, getInConviction, getQuestionClusterPositions, internalCreate, internalGetByProject, internalGetByTopic, isActiveQuestionNode, linkToBelief, linkToInsight, list, markAnsweredWithArtifact, matchesRequestedQuestionStatus, resolveLinkedWorktreeId, unlinkInsight, updateConviction, updatePriority, updateQuestion, updateStatus };
+//# sourceMappingURL=epistemicQuestions.js.map
+//# sourceMappingURL=epistemicQuestions.js.map