@lucern/graph-primitives 0.3.0-alpha.9 → 1.0.1

package/dist/epistemicEvidence.js

@@ -1,19 +1,12 @@
-import { v } from 'convex/values';
-import { requireProjectAccess, checkScopeAccess, checkProjectAccess } from '@lucern/access-control/access';
 import { canAudienceClassAccess, normalizeAudienceKey, classFromAudienceKey } from '@lucern/access-control/audience';
-import { listAudienceRegistryRows } from '@lucern/access-control/audienceRegistry';
+import { componentsGeneric, anyApi, mutationGeneric, internalMutationGeneric, queryGeneric, internalQueryGeneric } from 'convex/server';
+import { v } from 'convex/values';
+import { requireProjectAccess, checkProjectAccess, checkScopeAccess } from '@lucern/access-control/access';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { componentsGeneric, anyApi, mutationGeneric, queryGeneric, internalQueryGeneric, internalMutationGeneric } from 'convex/server';
 import { isNodeType, getLayerForNodeType } from '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
+import { listAudienceRegistryRows } from '@lucern/access-control/audienceRegistry';
 
-// src/epistemicEvidence.ts
-var api = anyApi;
-componentsGeneric();
-var internal = anyApi;
-var internalMutation = internalMutationGeneric;
-var internalQuery = internalQueryGeneric;
-var mutation = mutationGeneric;
-var query = queryGeneric;
+// src/epistemicEvidenceHelpers.ts
 
 // src/debug.ts
 function isGraphPrimitiveDebugEnabled() {
@@ -26,47 +19,13 @@ function debugGraphPrimitiveFallback(message, context) {
   }
   console.debug(message, context ?? {});
 }
-
-// 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 (error) {
-    debugGraphPrimitiveFallback(
-      "[embeddingTrigger] Failed to schedule embedding generation",
-      {
-        error,
-        nodeId: String(args.nodeId),
-        nodeType: args.nodeType
-      }
-    );
-  }
-}
-
-// 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)}`;
-}
+var api = anyApi;
+componentsGeneric();
+var internal = anyApi;
+var internalMutation = internalMutationGeneric;
+var internalQuery = internalQueryGeneric;
+var mutation = mutationGeneric;
+var query = queryGeneric;
 
 // src/topicProjectOverlay.ts
 var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
@@ -617,101 +576,12 @@ var optionalScopeArgs = {
   projectId: v.optional(v.string()),
   topicId: v.optional(v.string())
 };
-function normalizeScopeValue2(value) {
-  if (typeof value !== "string") {
-    return;
-  }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : void 0;
-}
-function throwWorkspaceIsolationError(args) {
-  const error = new Error(args.message);
-  error.status = 409;
-  error.code = "INVARIANT_VIOLATION";
-  error.invariantCode = args.invariantCode;
-  error.suggestion = args.suggestion;
-  error.details = args.details;
-  throw error;
-}
-function assertWorkspaceScopedEpistemicNodeScope(args) {
-  const layer = isNodeType(args.nodeType) ? getLayerForNodeType(args.nodeType) : void 0;
-  if (layer === "ontological") {
-    return;
-  }
-  const workspaceId = normalizeScopeValue2(args.scope.workspaceId);
-  if (workspaceId) {
-    return;
-  }
-  throwWorkspaceIsolationError({
-    message: "Workspace-scoped reasoning isolation requires workspaceId on non-ontological node creation.",
-    invariantCode: "workspace.scope_required_for_epistemic_nodes",
-    suggestion: "Resolve the topic/project scope through a workspace-bound topic before creating epistemic nodes.",
-    details: {
-      mutationName: args.mutationName,
-      nodeType: args.nodeType,
-      topicId: args.scope.topicId,
-      projectId: args.scope.projectId
-    }
-  });
-}
-function nodeMatchesWorkspaceReasoningScope(node, scope) {
-  if (!node) {
-    return false;
-  }
-  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
-  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
-  const nodeTenantId = normalizeScopeValue2(node.tenantId);
-  const nodeWorkspaceId = normalizeScopeValue2(node.workspaceId);
-  const epistemicLayer = typeof node.epistemicLayer === "string" ? node.epistemicLayer : void 0;
-  if (scopeTenantId && nodeTenantId && scopeTenantId !== nodeTenantId) {
-    return false;
-  }
-  if (epistemicLayer === "ontological" && nodeWorkspaceId === void 0) {
-    return true;
-  }
-  if (!scopeWorkspaceId && node.publicationStatus === "published") {
-    return true;
-  }
-  if (!scopeWorkspaceId) {
-    return nodeWorkspaceId === void 0;
-  }
-  return scopeWorkspaceId === nodeWorkspaceId;
-}
-function resolveRuntimePackMutationContext(args) {
-  if (!args.runtimeToolName && !args.runtimePackKey && !args.runtimePackInstallScope) {
-    return;
-  }
-  return {
-    toolName: args.runtimeToolName,
-    packKey: args.runtimePackKey,
-    packInstallScope: args.runtimePackInstallScope
-  };
-}
-function assertTenantPackWorkspaceMutationAllowed(args) {
-  if (!args.runtime?.packKey || args.runtime.packInstallScope !== "tenant") {
-    return;
-  }
-  const targetWorkspaceId = normalizeScopeValue2(args.target.workspaceId);
-  const targetLayer = typeof args.target.epistemicLayer === "string" ? args.target.epistemicLayer : void 0;
-  if (!targetWorkspaceId || targetLayer === "ontological") {
-    return;
-  }
-  throwWorkspaceIsolationError({
-    message: `Tenant-scoped pack "${args.runtime.packKey}" cannot mutate workspace-scoped reasoning state.`,
-    invariantCode: "workspace.tenant_pack_reasoning_write_forbidden",
-    suggestion: "Use a workspace-scoped pack for workspace-local graph mutations, or route the change through tenant-global canonical entity flows.",
-    details: {
-      mutationName: args.mutationName,
-      toolName: args.runtime.toolName,
-      packKey: args.runtime.packKey,
-      targetWorkspaceId,
-      targetNodeType: args.target.nodeType,
-      targetLayer
-    }
-  });
-}
 
-// src/epistemicEvidence.ts
+// src/epistemicEvidenceHelpers.ts
+var optionalEvidenceScopeArgs = optionalScopeArgs;
+var DEFAULT_EVIDENCE_PAGE_SIZE = 250;
+var MAX_EVIDENCE_PAGE_SIZE = 1e3;
+var LEGACY_SPRINT_LINK_KEY = "linkedSprintId";
 function generateContentHash(text) {
   const content = `evidence:${text.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 500)}`;
   let hash = 5381;
@@ -773,10 +643,6 @@ async function markProjectGraphDirty(ctx, projectId, topicId) {
     }
   );
 }
-var DEFAULT_EVIDENCE_PAGE_SIZE = 250;
-var MAX_EVIDENCE_PAGE_SIZE = 1e3;
-var LEGACY_SPRINT_LINK_KEY = "linkedSprintId";
-var optionalEvidenceScopeArgs = optionalScopeArgs;
 function clampEvidenceLimit(limit, fallback = DEFAULT_EVIDENCE_PAGE_SIZE) {
   if (!Number.isFinite(limit)) {
     return fallback;
@@ -839,7 +705,7 @@ async function getEvidenceNodesForScope(ctx, scope, args) {
   ).order("desc").take(scanLimit) : ctx.db.query("epistemicNodes").withIndex(
     "by_topic_type",
     (q) => q.eq("topicId", scope.topicId).eq("nodeType", "evidence")
-  ).collect());
+  ).order("desc").collect());
   return dedupeEvidenceNodes(topicNodes).filter(
     (node) => evidenceMatchesScope(node, scope)
   );
@@ -877,111 +743,572 @@ function flattenEvidenceNode(n) {
     externalSourceType: meta.externalSourceType || void 0
   };
 }
-var create = mutation({
-  args: {
-    ...optionalEvidenceScopeArgs,
-    text: v.string(),
-    title: v.optional(v.string()),
-    content: v.optional(v.string()),
-    contentType: v.optional(v.string()),
-    kind: v.optional(v.string()),
-    tags: v.optional(v.array(v.string())),
-    sourceType: v.optional(v.string()),
-    externalSourceType: v.optional(v.string()),
-    sourceUrl: v.optional(v.string()),
-    sourceQuestionId: v.optional(v.string()),
-    userId: v.string(),
-    rationale: v.string(),
-    // Classification fields (from AI tools)
-    methodology: v.optional(v.string()),
-    informationAsymmetry: v.optional(v.string()),
-    sourceDescription: v.optional(v.string()),
-    metadata: v.optional(v.any()),
-    // Optional linking to beliefs
-    linkedBeliefNodeId: v.optional(v.id("epistemicNodes")),
-    evidenceRelation: v.optional(
-      v.union(v.literal("supports"), v.literal("contradicts"))
-    ),
-    confidence: v.optional(v.number())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const scope = await resolveTopicProjectScope(ctx, {
-      topicId: args.topicId,
-      projectId: args.projectId
-    });
-    assertWorkspaceScopedEpistemicNodeScope({
-      scope,
-      nodeType: "evidence",
-      mutationName: "epistemicEvidence.create"
-    });
-    if (scope.projectId) {
-      await requireProjectAccess(ctx, scope.projectId, args.userId);
-    }
-    const now = Date.now();
-    const globalId = generateGlobalId();
-    const contentHash = generateContentHash(args.text);
-    const kind = normalizeKind(args.kind);
-    const sourceType = normalizeSourceType(args.sourceType);
-    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: "evidence",
-      canonicalText: args.text,
-      contentHash,
-      ...typeof args.title === "string" && args.title.trim().length > 0 ? { title: args.title.trim() } : {},
-      ...typeof args.content === "string" && args.content.length > 0 ? { content: args.content } : {},
-      ...typeof args.contentType === "string" && args.contentType.trim().length > 0 ? { contentType: args.contentType.trim() } : {},
-      status: "active",
-      epistemicLayer: "L2",
-      // L2: Compression Boundary (Evidence/Claims)
-      sourceType,
-      createdAt: now,
-      updatedAt: now,
-      createdBy: args.userId,
-      metadata: {
-        kind,
-        tags: args.tags || [],
-        externalSourceType: args.externalSourceType,
-        sourceUrl: args.sourceUrl,
-        sourceQuestionId: args.sourceQuestionId,
-        rationale: args.rationale,
-        linkedBeliefNodeId: args.linkedBeliefNodeId,
-        evidenceRelation: args.evidenceRelation,
-        confidence: args.confidence,
-        methodology: args.methodology,
-        informationAsymmetry: args.informationAsymmetry,
-        sourceDescription: args.sourceDescription,
-        ...additionalMetadata
-      }
-    });
-    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: "evidence",
-      text: args.text
-    });
-    if (args.linkedBeliefNodeId && args.evidenceRelation) {
-      const beliefNode = await ctx.db.get(args.linkedBeliefNodeId);
+function formatEvidenceNode(n) {
+  const metadata = n.metadata || {};
+  const linkedWorktreeId = resolveEvidenceLinkedWorktreeId(metadata);
+  return {
+    _id: n._id,
+    _epistemicNodeId: n._id,
+    _creationTime: n.createdAt,
+    projectId: n.projectId,
+    topicId: n.topicId,
+    text: n.canonicalText,
+    kind: metadata.kind || "observation",
+    tags: metadata.tags || [],
+    sourceType: n.sourceType,
+    externalSourceType: metadata.externalSourceType,
+    externalSourceUrl: metadata.sourceUrl,
+    sourceArtifactId: metadata.sourceArtifactId,
+    sourceQuestionId: metadata.sourceQuestionId,
+    linkedWorktreeId,
+    [LEGACY_SPRINT_LINK_KEY]: metadata[LEGACY_SPRINT_LINK_KEY] || void 0,
+    sourceAnchor: metadata.sourceAnchor,
+    aiProvider: metadata.aiProvider,
+    verificationStatus: metadata.verificationStatus,
+    status: n.status,
+    createdBy: n.createdBy,
+    createdAt: n.createdAt,
+    updatedAt: n.updatedAt
+  };
+}
+
+// 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 (error) {
+    debugGraphPrimitiveFallback(
+      "[embeddingTrigger] Failed to schedule embedding generation",
+      {
+        error,
+        nodeId: String(args.nodeId),
+        nodeType: args.nodeType
+      }
+    );
+  }
+}
+
+// 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)}`;
+}
+function normalizeScopeValue2(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function throwWorkspaceIsolationError(args) {
+  const error = new Error(args.message);
+  error.status = 409;
+  error.code = "INVARIANT_VIOLATION";
+  error.invariantCode = args.invariantCode;
+  error.suggestion = args.suggestion;
+  error.details = args.details;
+  throw error;
+}
+function assertWorkspaceScopedEpistemicNodeScope(args) {
+  const layer = isNodeType(args.nodeType) ? getLayerForNodeType(args.nodeType) : void 0;
+  if (layer === "ontological") {
+    return;
+  }
+  const workspaceId = normalizeScopeValue2(args.scope.workspaceId);
+  if (workspaceId) {
+    return;
+  }
+  throwWorkspaceIsolationError({
+    message: "Workspace-scoped reasoning isolation requires workspaceId on non-ontological node creation.",
+    invariantCode: "workspace.scope_required_for_epistemic_nodes",
+    suggestion: "Resolve the topic/project scope through a workspace-bound topic before creating epistemic nodes.",
+    details: {
+      mutationName: args.mutationName,
+      nodeType: args.nodeType,
+      topicId: args.scope.topicId,
+      projectId: args.scope.projectId
+    }
+  });
+}
+function nodeMatchesWorkspaceReasoningScope(node, scope) {
+  if (!node) {
+    return false;
+  }
+  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
+  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
+  const nodeTenantId = normalizeScopeValue2(node.tenantId);
+  const nodeWorkspaceId = normalizeScopeValue2(node.workspaceId);
+  const epistemicLayer = typeof node.epistemicLayer === "string" ? node.epistemicLayer : void 0;
+  if (scopeTenantId && nodeTenantId && scopeTenantId !== nodeTenantId) {
+    return false;
+  }
+  if (epistemicLayer === "ontological" && nodeWorkspaceId === void 0) {
+    return true;
+  }
+  if (!scopeWorkspaceId && node.publicationStatus === "published") {
+    return true;
+  }
+  if (!scopeWorkspaceId) {
+    return nodeWorkspaceId === void 0;
+  }
+  return scopeWorkspaceId === nodeWorkspaceId;
+}
+function resolveRuntimePackMutationContext(args) {
+  if (!args.runtimeToolName && !args.runtimePackKey && !args.runtimePackInstallScope) {
+    return;
+  }
+  return {
+    toolName: args.runtimeToolName,
+    packKey: args.runtimePackKey,
+    packInstallScope: args.runtimePackInstallScope
+  };
+}
+function assertTenantPackWorkspaceMutationAllowed(args) {
+  if (!args.runtime?.packKey || args.runtime.packInstallScope !== "tenant") {
+    return;
+  }
+  const targetWorkspaceId = normalizeScopeValue2(args.target.workspaceId);
+  const targetLayer = typeof args.target.epistemicLayer === "string" ? args.target.epistemicLayer : void 0;
+  if (!targetWorkspaceId || targetLayer === "ontological") {
+    return;
+  }
+  throwWorkspaceIsolationError({
+    message: `Tenant-scoped pack "${args.runtime.packKey}" cannot mutate workspace-scoped reasoning state.`,
+    invariantCode: "workspace.tenant_pack_reasoning_write_forbidden",
+    suggestion: "Use a workspace-scoped pack for workspace-local graph mutations, or route the change through tenant-global canonical entity flows.",
+    details: {
+      mutationName: args.mutationName,
+      toolName: args.runtime.toolName,
+      packKey: args.runtime.packKey,
+      targetWorkspaceId,
+      targetNodeType: args.target.nodeType,
+      targetLayer
+    }
+  });
+}
+
+// src/epistemicEvidenceMutations.ts
+var create = mutation({
+  args: {
+    ...optionalEvidenceScopeArgs,
+    text: v.string(),
+    title: v.optional(v.string()),
+    content: v.optional(v.string()),
+    contentType: v.optional(v.string()),
+    kind: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+    sourceType: v.optional(v.string()),
+    externalSourceType: v.optional(v.string()),
+    sourceUrl: v.optional(v.string()),
+    sourceQuestionId: v.optional(v.string()),
+    userId: v.string(),
+    rationale: v.string(),
+    // Classification fields (from AI tools)
+    methodology: v.optional(v.string()),
+    informationAsymmetry: v.optional(v.string()),
+    sourceDescription: v.optional(v.string()),
+    metadata: v.optional(v.any()),
+    // Optional linking to beliefs
+    linkedBeliefNodeId: v.optional(v.id("epistemicNodes")),
+    evidenceRelation: v.optional(
+      v.union(v.literal("supports"), v.literal("contradicts"))
+    ),
+    confidence: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveEvidenceScopeOrNull(ctx, args);
+    if (!scope) {
+      throw new Error("Invalid scope: projectId or topicId is required");
+    }
+    assertWorkspaceScopedEpistemicNodeScope({
+      scope,
+      nodeType: "evidence",
+      mutationName: "epistemicEvidence.create"
+    });
+    if (scope.projectId) {
+      await requireProjectAccess(ctx, scope.projectId, args.userId);
+    }
+    const now = Date.now();
+    const globalId = generateGlobalId();
+    const contentHash = generateContentHash(args.text);
+    const kind = normalizeKind(args.kind);
+    const sourceType = normalizeSourceType(args.sourceType);
+    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: "evidence",
+      canonicalText: args.text,
+      contentHash,
+      ...typeof args.title === "string" && args.title.trim().length > 0 ? { title: args.title.trim() } : {},
+      ...typeof args.content === "string" && args.content.length > 0 ? { content: args.content } : {},
+      ...typeof args.contentType === "string" && args.contentType.trim().length > 0 ? { contentType: args.contentType.trim() } : {},
+      status: "active",
+      epistemicLayer: "L2",
+      sourceType,
+      createdAt: now,
+      updatedAt: now,
+      createdBy: args.userId,
+      metadata: {
+        kind,
+        tags: args.tags || [],
+        externalSourceType: args.externalSourceType,
+        sourceUrl: args.sourceUrl,
+        sourceQuestionId: args.sourceQuestionId,
+        rationale: args.rationale,
+        linkedBeliefNodeId: args.linkedBeliefNodeId,
+        evidenceRelation: args.evidenceRelation,
+        confidence: args.confidence,
+        methodology: args.methodology,
+        informationAsymmetry: args.informationAsymmetry,
+        sourceDescription: args.sourceDescription,
+        ...additionalMetadata
+      }
+    });
+    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: "evidence",
+      text: args.text
+    });
+    if (args.linkedBeliefNodeId && args.evidenceRelation) {
+      const beliefNode = await ctx.db.get(args.linkedBeliefNodeId);
+      if (beliefNode) {
+        const weight = args.evidenceRelation === "supports" ? 1 : -1;
+        await ctx.scheduler.runAfter(5e3, internal.neo4jEdgeAPI.createEdge, {
+          globalId: crypto.randomUUID(),
+          fromGlobalId: globalId,
+          toGlobalId: beliefNode.globalId,
+          edgeType: "informs",
+          weight: weight * (args.confidence || 0.7),
+          createdBy: args.userId,
+          topicId: scope.projectId ? String(scope.projectId) : void 0,
+          fromNodeType: "evidence",
+          toNodeType: "belief",
+          fromLayer: "L2",
+          toLayer: "L3",
+          metadata: {
+            relation: args.evidenceRelation,
+            confidence: args.confidence
+          }
+        });
+      }
+    }
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "evidence",
+      entityId: nodeId,
+      changeType: "created",
+      changedAt: now,
+      changedBy: args.userId,
+      isAgent: false,
+      projectId: scope.projectId,
+      rationale: args.rationale,
+      newState: {
+        text: args.text.slice(0, 200),
+        kind,
+        sourceType,
+        linkedBeliefNodeId: args.linkedBeliefNodeId,
+        evidenceRelation: args.evidenceRelation
+      }
+    });
+    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: "evidence",
+          text: args.text
+        }
+      );
+    }
+    if (scope.projectId || scope.topicId) {
+      await ctx.scheduler.runAfter(
+        2e3,
+        internal.nodeClassification.scheduleClassification,
+        {
+          nodeId,
+          nodeType: "evidence",
+          projectId: scope.projectId,
+          topicId: String(scope.topicId)
+        }
+      );
+    }
+    await markProjectGraphDirty(ctx, scope.projectId, String(scope.topicId));
+    return { nodeId };
+  }
+});
+var createAndLink = mutation({
+  args: {
+    ...optionalEvidenceScopeArgs,
+    text: v.string(),
+    kind: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+    sourceType: v.optional(v.string()),
+    userId: v.string(),
+    beliefNodeId: v.id("epistemicNodes"),
+    relation: v.union(v.literal("supports"), v.literal("contradicts")),
+    confidence: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const scope = await resolveEvidenceScopeOrNull(ctx, args);
+    if (!scope) {
+      throw new Error("Invalid scope: projectId or topicId is required");
+    }
+    await requireProjectAccess(ctx, String(scope.topicId), args.userId);
+    const now = Date.now();
+    const globalId = generateGlobalId();
+    const contentHash = generateContentHash(args.text);
+    const kind = normalizeKind(args.kind);
+    const sourceType = normalizeSourceType(args.sourceType);
+    const confidence = args.confidence ?? 0.7;
+    const nodeId = await ctx.db.insert("epistemicNodes", {
+      globalId,
+      topicId: scope.topicId,
+      projectId: scope.projectId,
+      tenantId: scope.tenantId,
+      workspaceId: scope.workspaceId,
+      nodeType: "evidence",
+      canonicalText: args.text,
+      contentHash,
+      status: "active",
+      epistemicLayer: "L2",
+      sourceType,
+      createdAt: now,
+      updatedAt: now,
+      createdBy: args.userId,
+      metadata: {
+        kind,
+        tags: args.tags || [],
+        linkedBeliefNodeId: args.beliefNodeId,
+        evidenceRelation: args.relation,
+        confidence
+      }
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId,
+      operation: "upsert"
+    });
+    const beliefNode = await ctx.db.get(args.beliefNodeId);
+    if (!beliefNode) {
+      throw new Error("Belief node not found for edge creation");
+    }
+    const weight = args.relation === "supports" ? confidence : -confidence;
+    const edgeGlobalId = crypto.randomUUID();
+    await ctx.scheduler.runAfter(5e3, internal.neo4jEdgeAPI.createEdge, {
+      globalId: edgeGlobalId,
+      fromGlobalId: globalId,
+      toGlobalId: beliefNode.globalId,
+      edgeType: "informs",
+      weight,
+      createdBy: args.userId,
+      topicId: scope.projectId,
+      fromNodeType: "evidence",
+      toNodeType: "belief",
+      fromLayer: "L2",
+      toLayer: "L3",
+      metadata: {
+        relation: args.relation,
+        confidence
+      }
+    });
+    await markProjectGraphDirty(ctx, scope.projectId, String(scope.topicId));
+    return { nodeId, edgeGlobalId };
+  }
+});
+var updateStatus = mutation({
+  args: {
+    nodeId: v.id("epistemicNodes"),
+    status: v.union(
+      v.literal("active"),
+      v.literal("archived"),
+      v.literal("acted_on")
+    ),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = await ctx.db.get(args.nodeId);
+    if (!node || node.nodeType !== "evidence") {
+      throw new Error("Evidence not found");
+    }
+    const now = Date.now();
+    await ctx.db.patch(args.nodeId, {
+      status: args.status,
+      updatedAt: now
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "evidence",
+      entityId: args.nodeId,
+      changeType: "status_changed",
+      changedAt: now,
+      changedBy: args.userId,
+      isAgent: false,
+      projectId: node.projectId,
+      previousState: { status: node.status },
+      newState: { status: args.status }
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: args.nodeId,
+      operation: "upsert"
+    });
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+    return { nodeId: args.nodeId };
+  }
+});
+var internalCreate = internalMutation({
+  args: {
+    ...optionalEvidenceScopeArgs,
+    text: v.string(),
+    title: v.optional(v.string()),
+    content: v.optional(v.string()),
+    contentType: v.optional(v.string()),
+    kind: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+    sourceType: v.optional(v.string()),
+    externalSourceType: v.optional(v.string()),
+    sourceUrl: v.optional(v.string()),
+    sourceQuestionId: v.optional(v.string()),
+    userId: v.string(),
+    rationale: v.string(),
+    linkedBeliefNodeId: v.optional(v.id("epistemicNodes")),
+    evidenceRelation: v.optional(v.string()),
+    confidence: v.optional(v.number()),
+    metadata: v.optional(v.any()),
+    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 resolveEvidenceScopeOrNull(ctx, args);
+    if (!scope) {
+      throw new Error("Invalid scope: projectId or topicId is required");
+    }
+    assertWorkspaceScopedEpistemicNodeScope({
+      scope,
+      nodeType: "evidence",
+      mutationName: "epistemicEvidence.internalCreate"
+    });
+    assertTenantPackWorkspaceMutationAllowed({
+      runtime: resolveRuntimePackMutationContext(args),
+      target: {
+        tenantId: scope.tenantId,
+        workspaceId: scope.workspaceId,
+        nodeType: "evidence",
+        epistemicLayer: "L2"
+      },
+      mutationName: "epistemicEvidence.internalCreate"
+    });
+    const globalId = generateGlobalId();
+    const contentHash = generateContentHash(args.text);
+    const kind = normalizeKind(args.kind);
+    const sourceType = normalizeSourceType(args.sourceType);
+    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: "evidence",
+      canonicalText: args.text,
+      contentHash,
+      ...typeof args.title === "string" && args.title.trim().length > 0 ? { title: args.title.trim() } : {},
+      ...typeof args.content === "string" && args.content.length > 0 ? { content: args.content } : {},
+      ...typeof args.contentType === "string" && args.contentType.trim().length > 0 ? { contentType: args.contentType.trim() } : {},
+      status: "active",
+      epistemicLayer: "L2",
+      sourceType,
+      createdAt: now,
+      updatedAt: now,
+      createdBy: args.userId,
+      metadata: {
+        kind,
+        tags: args.tags || [],
+        externalSourceType: args.externalSourceType,
+        sourceUrl: args.sourceUrl,
+        sourceQuestionId: args.sourceQuestionId,
+        rationale: args.rationale,
+        linkedBeliefNodeId: args.linkedBeliefNodeId,
+        evidenceRelation: args.evidenceRelation,
+        confidence: args.confidence,
+        ...additionalMetadata
+      }
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "evidence",
+      entityId: String(nodeId),
+      changeType: "created",
+      changedAt: now,
+      changedBy: args.userId,
+      isAgent: false,
+      projectId: scope.projectId,
+      rationale: args.rationale,
+      newState: {
+        text: args.text.slice(0, 200),
+        kind,
+        sourceType,
+        externalSourceType: args.externalSourceType,
+        sourceUrl: args.sourceUrl,
+        linkedBeliefNodeId: args.linkedBeliefNodeId,
+        evidenceRelation: args.evidenceRelation,
+        confidence: args.confidence
+      },
+      triggeringAction: "epistemicEvidence.internalCreate"
+    });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId,
+      operation: "upsert"
+    });
+    if (args.linkedBeliefNodeId && args.evidenceRelation) {
+      const beliefNode = await ctx.db.get(args.linkedBeliefNodeId);
       if (beliefNode) {
-        const weight = args.evidenceRelation === "supports" ? 1 : -1;
+        const confidence = args.confidence ?? 0.7;
+        const weight = args.evidenceRelation === "supports" ? confidence : -confidence;
         await ctx.scheduler.runAfter(5e3, internal.neo4jEdgeAPI.createEdge, {
           globalId: crypto.randomUUID(),
           fromGlobalId: globalId,
           toGlobalId: beliefNode.globalId,
           edgeType: "informs",
-          weight: weight * (args.confidence || 0.7),
+          weight,
           createdBy: args.userId,
           topicId: scope.projectId ? String(scope.projectId) : void 0,
           fromNodeType: "evidence",
@@ -990,28 +1317,11 @@ var create = mutation({
           toLayer: "L3",
           metadata: {
             relation: args.evidenceRelation,
-            confidence: args.confidence
+            confidence
           }
         });
       }
     }
-    await ctx.db.insert("epistemicAudit", {
-      entityType: "evidence",
-      entityId: nodeId,
-      changeType: "created",
-      changedAt: now,
-      changedBy: args.userId,
-      isAgent: false,
-      projectId: scope.projectId,
-      rationale: args.rationale,
-      newState: {
-        text: args.text.slice(0, 200),
-        kind,
-        sourceType,
-        linkedBeliefNodeId: args.linkedBeliefNodeId,
-        evidenceRelation: args.evidenceRelation
-      }
-    });
     if (scope.projectId || scope.topicId) {
       await ctx.scheduler.runAfter(
         0,
@@ -1026,140 +1336,217 @@ var create = mutation({
         }
       );
     }
-    if (scope.projectId || scope.topicId) {
-      await ctx.scheduler.runAfter(
-        2e3,
-        // 2 second delay
-        internal.nodeClassification.scheduleClassification,
-        {
-          nodeId,
-          nodeType: "evidence",
-          projectId: scope.projectId,
-          topicId: String(scope.topicId)
-        }
-      );
-    }
     await markProjectGraphDirty(ctx, scope.projectId, String(scope.topicId));
     return { nodeId };
   }
 });
-var createAndLink = mutation({
+var updateVerificationStatus = mutation({
   args: {
-    ...optionalEvidenceScopeArgs,
-    text: v.string(),
+    nodeId: v.id("epistemicNodes"),
+    verificationHash: v.string(),
+    verificationStatus: v.string(),
+    lastVerificationId: v.optional(v.id("verificationResults"))
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const node = await ctx.db.get(args.nodeId);
+    if (!node || node.nodeType !== "evidence") {
+      throw new Error("Evidence node not found");
+    }
+    const metadata = node.metadata || {};
+    await ctx.db.patch(args.nodeId, {
+      metadata: {
+        ...metadata,
+        verificationHash: args.verificationHash,
+        verificationStatus: args.verificationStatus,
+        lastVerificationId: args.lastVerificationId
+      }
+    });
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+    return { success: true };
+  }
+});
+var update = mutation({
+  args: {
+    nodeId: v.optional(v.id("epistemicNodes")),
+    insightId: v.optional(v.string()),
+    text: v.optional(v.string()),
     kind: v.optional(v.string()),
     tags: v.optional(v.array(v.string())),
-    sourceType: v.optional(v.string()),
     userId: v.string(),
-    beliefNodeId: v.id("epistemicNodes"),
-    relation: v.union(v.literal("supports"), v.literal("contradicts")),
-    confidence: v.optional(v.number())
+    externalSourceUrl: v.optional(v.string()),
+    verificationStatus: v.optional(v.string())
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const scope = await resolveTopicProjectScope(ctx, {
-      topicId: args.topicId,
-      projectId: args.projectId
-    });
-    await requireProjectAccess(ctx, String(scope.topicId), args.userId);
+    const resolvedId = args.nodeId ?? args.insightId;
+    if (!resolvedId) {
+      throw new Error("Either nodeId or insightId is required");
+    }
+    const node = await ctx.db.get(resolvedId);
+    if (!node || node.nodeType !== "evidence") {
+      throw new Error("Evidence node not found");
+    }
+    if (!node.projectId) {
+      throw new Error("Evidence has no project scope");
+    }
+    await checkProjectAccess(ctx, node.projectId, args.userId);
     const now = Date.now();
-    const globalId = generateGlobalId();
-    const contentHash = generateContentHash(args.text);
-    const kind = normalizeKind(args.kind);
-    const sourceType = normalizeSourceType(args.sourceType);
-    const confidence = args.confidence ?? 0.7;
-    const nodeId = await ctx.db.insert("epistemicNodes", {
-      globalId,
-      topicId: scope.topicId,
-      projectId: scope.projectId,
-      tenantId: scope.tenantId,
-      workspaceId: scope.workspaceId,
-      nodeType: "evidence",
-      canonicalText: args.text,
-      contentHash,
-      status: "active",
-      epistemicLayer: "L2",
-      sourceType,
-      createdAt: now,
-      updatedAt: now,
-      createdBy: args.userId,
-      metadata: {
-        kind,
-        tags: args.tags || [],
-        linkedBeliefNodeId: args.beliefNodeId,
-        evidenceRelation: args.relation,
-        confidence
-      }
+    const existingMeta = node.metadata || {};
+    const metaUpdates = { ...existingMeta };
+    if (args.kind !== void 0) {
+      metaUpdates.kind = args.kind;
+    }
+    if (args.tags !== void 0) {
+      metaUpdates.tags = args.tags;
+    }
+    if (args.externalSourceUrl !== void 0) {
+      metaUpdates.externalSourceUrl = args.externalSourceUrl;
+    }
+    await ctx.db.patch(resolvedId, {
+      canonicalText: args.text ?? node.canonicalText,
+      metadata: metaUpdates,
+      updatedAt: now
     });
     await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
-      nodeId,
+      nodeId: resolvedId,
       operation: "upsert"
     });
-    const beliefNode = await ctx.db.get(args.beliefNodeId);
-    if (!beliefNode) {
-      throw new Error("Belief node not found for edge creation");
-    }
-    const weight = args.relation === "supports" ? confidence : -confidence;
-    const edgeGlobalId = crypto.randomUUID();
-    await ctx.scheduler.runAfter(5e3, internal.neo4jEdgeAPI.createEdge, {
-      globalId: edgeGlobalId,
-      fromGlobalId: globalId,
-      toGlobalId: beliefNode.globalId,
-      edgeType: "informs",
-      weight,
-      createdBy: args.userId,
-      topicId: scope.projectId,
-      fromNodeType: "evidence",
-      toNodeType: "belief",
-      fromLayer: "L2",
-      toLayer: "L3",
-      metadata: {
-        relation: args.relation,
-        confidence
-      }
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "evidence",
+      entityId: resolvedId,
+      changeType: "updated",
+      changedAt: now,
+      changedBy: args.userId,
+      isAgent: false,
+      projectId: node.projectId,
+      previousState: { text: node.canonicalText?.slice(0, 200) },
+      newState: { text: (args.text ?? node.canonicalText)?.slice(0, 200) }
     });
-    await markProjectGraphDirty(ctx, scope.projectId, String(scope.topicId));
-    return { nodeId, edgeGlobalId };
+    if (args.text !== void 0) {
+      await ctx.scheduler.runAfter(
+        0,
+        "embeddingActions:generateEpistemicNodeEmbedding",
+        {
+          nodeId: resolvedId,
+          topicId: node.projectId,
+          createdBy: node.createdBy,
+          nodeType: "evidence",
+          text: args.text
+        }
+      );
+    }
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+    return { nodeId: resolvedId };
   }
 });
-var updateStatus = mutation({
+var flagAsIncorrect = mutation({
   args: {
-    nodeId: v.id("epistemicNodes"),
-    status: v.union(
-      v.literal("active"),
-      v.literal("archived"),
-      v.literal("acted_on")
-    ),
+    insightId: v.id("epistemicNodes"),
+    reason: v.string(),
+    suggestedCorrection: v.optional(v.string()),
+    userId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const node = await ctx.db.get(args.insightId);
+    if (!node || node.nodeType !== "evidence") {
+      throw new Error("Evidence not found in epistemic spine");
+    }
+    if (!node.projectId) {
+      throw new Error("Evidence has no project scope");
+    }
+    await checkProjectAccess(ctx, node.projectId, args.userId);
+    const existingMeta = node.metadata || {};
+    await ctx.db.patch(node._id, {
+      verificationStatus: "contradicted",
+      metadata: {
+        ...existingMeta,
+        contradictionReason: args.reason,
+        suggestedCorrection: args.suggestedCorrection,
+        contradictedBy: args.userId,
+        contradictedAt: now
+      },
+      updatedAt: now
+    });
+    await ctx.db.insert("verificationResults", {
+      targetType: "insight",
+      targetId: node._id,
+      claimText: node.canonicalText || "Evidence text not available",
+      verdict: "contradicted",
+      confidence: 1,
+      sources: [],
+      reasoning: args.reason,
+      suggestedRevision: args.suggestedCorrection,
+      caveats: [],
+      mode: "deep_verify",
+      verifiedAt: now,
+      durationMs: 0,
+      projectId: node.projectId,
+      userId: args.userId
+    });
+    await ctx.db.insert("epistemicAudit", {
+      entityType: "evidence",
+      entityId: node._id,
+      changeType: "updated",
+      changedAt: now,
+      changedBy: args.userId,
+      isAgent: false,
+      projectId: node.projectId,
+      newState: {
+        reason: args.reason,
+        suggestedCorrection: args.suggestedCorrection
+      }
+    });
+    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
+    console.log(
+      `[EpistemicEvidence] Evidence flagged as incorrect by ${args.userId}: "${args.insightId.slice(0, 20)}..."`
+    );
+    return { success: true };
+  }
+});
+var remove = mutation({
+  args: {
+    nodeId: v.optional(v.id("epistemicNodes")),
+    insightId: v.optional(v.string()),
     userId: v.string()
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.nodeId);
+    const resolvedId = args.nodeId ?? args.insightId;
+    if (!resolvedId) {
+      throw new Error("Either nodeId or insightId is required");
+    }
+    const node = await ctx.db.get(resolvedId);
     if (!node || node.nodeType !== "evidence") {
-      throw new Error("Evidence not found");
+      throw new Error("Evidence node not found");
+    }
+    if (node.createdBy !== args.userId) {
+      throw new Error("Only the creator can archive this evidence");
     }
     const now = Date.now();
-    await ctx.db.patch(args.nodeId, {
-      status: args.status,
+    await ctx.db.patch(resolvedId, {
+      status: "archived",
       updatedAt: now
     });
+    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
+      nodeId: resolvedId,
+      operation: "upsert"
+    });
     await ctx.db.insert("epistemicAudit", {
       entityType: "evidence",
-      entityId: args.nodeId,
-      changeType: "status_changed",
+      entityId: resolvedId,
+      changeType: "archived",
       changedAt: now,
       changedBy: args.userId,
       isAgent: false,
       projectId: node.projectId,
       previousState: { status: node.status },
-      newState: { status: args.status }
-    });
-    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
-      nodeId: args.nodeId,
-      operation: "upsert"
+      newState: { status: "archived" }
     });
     await markProjectGraphDirty(ctx, node.projectId, node.topicId);
-    return { nodeId: args.nodeId };
+    return { nodeId: resolvedId };
   }
 });
 var getById = query({
@@ -1174,9 +1561,7 @@ var getById = query({
     if (!id) {
       return null;
     }
-    const node = await ctx.db.get(
-      id
-    );
+    const node = await ctx.db.get(id);
     if (!node || node.nodeType !== "evidence") {
       return null;
     }
@@ -1196,7 +1581,7 @@ var getByProject = query({
       return [];
     }
     const pageSize = clampEvidenceLimit(args.limit);
-    const scanLimit = Math.min(pageSize * 3, MAX_EVIDENCE_PAGE_SIZE);
+    const scanLimit = Math.min(pageSize * 3, 1e3);
     let scope;
     try {
       scope = await resolveTopicProjectScope(ctx, {
@@ -1245,7 +1630,7 @@ var getByTopic = query({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const pageSize = clampEvidenceLimit(args.limit);
-    const scanLimit = Math.min(pageSize * 3, MAX_EVIDENCE_PAGE_SIZE);
+    const scanLimit = Math.min(pageSize * 3, 1e3);
     const scope = await resolveTopicProjectScope(ctx, {
       topicId: args.topicId
     });
@@ -1292,7 +1677,7 @@ var internalGetByProject = internalQuery({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const pageSize = clampEvidenceLimit(args.limit, 500);
-    const scanLimit = Math.min(pageSize * 3, MAX_EVIDENCE_PAGE_SIZE);
+    const scanLimit = Math.min(pageSize * 3, 1e3);
     const scope = await resolveEvidenceScopeOrNull(ctx, args);
     if (!scope) {
       return [];
@@ -1356,264 +1741,58 @@ var internalGetByTopic = internalQuery({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const pageSize = clampEvidenceLimit(args.limit, 500);
-    const scanLimit = Math.min(pageSize * 3, MAX_EVIDENCE_PAGE_SIZE);
+    const scanLimit = Math.min(pageSize * 3, 1e3);
     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 resolveAudienceClass = createEvidenceAudienceResolver(registryRows);
-    const viewerClass = resolveAudienceClass(audienceMode, "public");
-    const nodes = await ctx.db.query("epistemicNodes").withIndex(
-      "by_topic_type",
-      (q) => q.eq("topicId", args.topicId).eq("nodeType", "evidence")
-    ).order("desc").take(scanLimit);
-    const workspaceScopedNodes = nodes.filter(
-      (node) => nodeMatchesWorkspaceReasoningScope(node, {
-        tenantId: scope.tenantId,
-        workspaceId: scope.workspaceId
-      })
-    );
-    return workspaceScopedNodes.filter(
-      (n) => canAudienceClassAccess(
-        viewerClass,
-        resolveAudienceClass(n.audienceLabel, "internal")
-      ) && (!args.status || n.status === args.status)
-    ).slice(0, pageSize).map((n) => {
-      const metadata = n.metadata || {};
-      return {
-        _id: n._id,
-        _creationTime: n.createdAt,
-        projectId: n.projectId,
-        topicId: n.topicId,
-        text: n.canonicalText,
-        kind: metadata.kind || "observation",
-        tags: metadata.tags || [],
-        sourceType: n.sourceType,
-        externalSourceType: metadata.externalSourceType,
-        sourceUrl: metadata.sourceUrl,
-        status: n.status,
-        createdBy: n.createdBy,
-        createdAt: n.createdAt,
-        updatedAt: n.updatedAt,
-        audienceLabel: n.audienceLabel,
-        policyTags: n.policyTags,
-        sensitivityTier: n.sensitivityTier,
-        exportClass: n.exportClass,
-        anonymizationClass: n.anonymizationClass
-      };
-    });
-  }
-});
-var internalCreate = internalMutation({
-  args: {
-    ...optionalEvidenceScopeArgs,
-    text: v.string(),
-    title: v.optional(v.string()),
-    content: v.optional(v.string()),
-    contentType: v.optional(v.string()),
-    kind: v.optional(v.string()),
-    tags: v.optional(v.array(v.string())),
-    sourceType: v.optional(v.string()),
-    externalSourceType: v.optional(v.string()),
-    sourceUrl: v.optional(v.string()),
-    sourceQuestionId: v.optional(v.string()),
-    userId: v.string(),
-    rationale: v.string(),
-    linkedBeliefNodeId: v.optional(v.id("epistemicNodes")),
-    evidenceRelation: v.optional(v.string()),
-    confidence: v.optional(v.number()),
-    /** Optional extra metadata fields merged into the node's metadata object.
-     *  Use for domain overlays like coding intelligence (codeAnchors, failedApproach, etc.) */
-    metadata: v.optional(v.any()),
-    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: "evidence",
-      mutationName: "epistemicEvidence.internalCreate"
-    });
-    assertTenantPackWorkspaceMutationAllowed({
-      runtime: resolveRuntimePackMutationContext(args),
-      target: {
-        tenantId: scope.tenantId,
-        workspaceId: scope.workspaceId,
-        nodeType: "evidence",
-        epistemicLayer: "L2"
-      },
-      mutationName: "epistemicEvidence.internalCreate"
-    });
-    const globalId = generateGlobalId();
-    const contentHash = generateContentHash(args.text);
-    const kind = normalizeKind(args.kind);
-    const sourceType = normalizeSourceType(args.sourceType);
-    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: "evidence",
-      canonicalText: args.text,
-      contentHash,
-      ...typeof args.title === "string" && args.title.trim().length > 0 ? { title: args.title.trim() } : {},
-      ...typeof args.content === "string" && args.content.length > 0 ? { content: args.content } : {},
-      ...typeof args.contentType === "string" && args.contentType.trim().length > 0 ? { contentType: args.contentType.trim() } : {},
-      status: "active",
-      epistemicLayer: "L2",
-      sourceType,
-      createdAt: now,
-      updatedAt: now,
-      createdBy: args.userId,
-      metadata: {
-        kind,
-        tags: args.tags || [],
-        externalSourceType: args.externalSourceType,
-        sourceUrl: args.sourceUrl,
-        sourceQuestionId: args.sourceQuestionId,
-        rationale: args.rationale,
-        linkedBeliefNodeId: args.linkedBeliefNodeId,
-        evidenceRelation: args.evidenceRelation,
-        confidence: args.confidence,
-        ...additionalMetadata
-      }
-    });
-    await ctx.db.insert("epistemicAudit", {
-      entityType: "evidence",
-      entityId: String(nodeId),
-      changeType: "created",
-      changedAt: now,
-      changedBy: args.userId,
-      isAgent: false,
-      projectId: scope.projectId,
-      rationale: args.rationale,
-      newState: {
-        text: args.text.slice(0, 200),
-        kind,
-        sourceType,
-        externalSourceType: args.externalSourceType,
-        sourceUrl: args.sourceUrl,
-        linkedBeliefNodeId: args.linkedBeliefNodeId,
-        evidenceRelation: args.evidenceRelation,
-        confidence: args.confidence
-      },
-      triggeringAction: "epistemicEvidence.internalCreate"
-    });
-    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
-      nodeId,
-      operation: "upsert"
-    });
-    if (args.linkedBeliefNodeId && args.evidenceRelation) {
-      const beliefNode = await ctx.db.get(args.linkedBeliefNodeId);
-      if (beliefNode) {
-        const confidence = args.confidence ?? 0.7;
-        const weight = args.evidenceRelation === "supports" ? confidence : -confidence;
-        await ctx.scheduler.runAfter(5e3, internal.neo4jEdgeAPI.createEdge, {
-          globalId: crypto.randomUUID(),
-          fromGlobalId: globalId,
-          toGlobalId: beliefNode.globalId,
-          edgeType: "informs",
-          weight,
-          createdBy: args.userId,
-          topicId: scope.projectId ? String(scope.projectId) : void 0,
-          fromNodeType: "evidence",
-          toNodeType: "belief",
-          fromLayer: "L2",
-          toLayer: "L3",
-          metadata: {
-            relation: args.evidenceRelation,
-            confidence
-          }
-        });
-      }
-    }
-    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: "evidence",
-          text: args.text
-        }
-      );
-    }
-    await markProjectGraphDirty(ctx, scope.projectId, String(scope.topicId));
-    return { nodeId };
-  }
-});
-var updateVerificationStatus = mutation({
-  args: {
-    nodeId: v.id("epistemicNodes"),
-    verificationHash: v.string(),
-    verificationStatus: v.string(),
-    lastVerificationId: v.optional(v.id("verificationResults"))
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const node = await ctx.db.get(args.nodeId);
-    if (!node || node.nodeType !== "evidence") {
-      throw new Error("Evidence node not found");
-    }
-    const metadata = node.metadata || {};
-    await ctx.db.patch(args.nodeId, {
-      metadata: {
-        ...metadata,
-        verificationHash: args.verificationHash,
-        verificationStatus: args.verificationStatus,
-        lastVerificationId: args.lastVerificationId
-      }
+      tenantId: scope.tenantId,
+      workspaceId: scope.workspaceId
+    });
+    const resolveAudienceClass = createEvidenceAudienceResolver(registryRows);
+    const viewerClass = resolveAudienceClass(audienceMode, "public");
+    const nodes = await ctx.db.query("epistemicNodes").withIndex(
+      "by_topic_type",
+      (q) => q.eq("topicId", args.topicId).eq("nodeType", "evidence")
+    ).order("desc").take(scanLimit);
+    const workspaceScopedNodes = nodes.filter(
+      (node) => nodeMatchesWorkspaceReasoningScope(node, {
+        tenantId: scope.tenantId,
+        workspaceId: scope.workspaceId
+      })
+    );
+    return workspaceScopedNodes.filter(
+      (n) => canAudienceClassAccess(
+        viewerClass,
+        resolveAudienceClass(n.audienceLabel, "internal")
+      ) && (!args.status || n.status === args.status)
+    ).slice(0, pageSize).map((n) => {
+      const metadata = n.metadata || {};
+      return {
+        _id: n._id,
+        _creationTime: n.createdAt,
+        projectId: n.projectId,
+        topicId: n.topicId,
+        text: n.canonicalText,
+        kind: metadata.kind || "observation",
+        tags: metadata.tags || [],
+        sourceType: n.sourceType,
+        externalSourceType: metadata.externalSourceType,
+        sourceUrl: metadata.sourceUrl,
+        status: n.status,
+        createdBy: n.createdBy,
+        createdAt: n.createdAt,
+        updatedAt: n.updatedAt,
+        audienceLabel: n.audienceLabel,
+        policyTags: n.policyTags,
+        sensitivityTier: n.sensitivityTier,
+        exportClass: n.exportClass,
+        anonymizationClass: n.anonymizationClass
+      };
     });
-    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
-    return { success: true };
   }
 });
-function formatEvidenceNode(n) {
-  const metadata = n.metadata || {};
-  const linkedWorktreeId = resolveEvidenceLinkedWorktreeId(metadata);
-  return {
-    _id: n._id,
-    _epistemicNodeId: n._id,
-    _creationTime: n.createdAt,
-    projectId: n.projectId,
-    topicId: n.topicId,
-    text: n.canonicalText,
-    kind: metadata.kind || "observation",
-    tags: metadata.tags || [],
-    sourceType: n.sourceType,
-    externalSourceType: metadata.externalSourceType,
-    externalSourceUrl: metadata.sourceUrl,
-    sourceArtifactId: metadata.sourceArtifactId,
-    sourceQuestionId: metadata.sourceQuestionId,
-    linkedWorktreeId,
-    [LEGACY_SPRINT_LINK_KEY]: metadata[LEGACY_SPRINT_LINK_KEY] || void 0,
-    sourceAnchor: metadata.sourceAnchor,
-    aiProvider: metadata.aiProvider,
-    verificationStatus: metadata.verificationStatus,
-    status: n.status,
-    createdBy: n.createdBy,
-    createdAt: n.createdAt,
-    updatedAt: n.updatedAt
-  };
-}
 var getByProjectSystem = query({
   args: {
     ...optionalEvidenceScopeArgs,
@@ -1623,7 +1802,7 @@ var getByProjectSystem = query({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const pageSize = clampEvidenceLimit(args.limit, 500);
-    const scanLimit = Math.min(pageSize * 3, MAX_EVIDENCE_PAGE_SIZE);
+    const scanLimit = Math.min(pageSize * 3, 1e3);
     const scope = await resolveEvidenceScopeOrNull(ctx, args);
     if (!scope) {
       return [];
@@ -1674,191 +1853,6 @@ var getEvidenceBalance = query({
     return { supporting, challenging, total: evidenceEdges.length };
   }
 });
-var update = mutation({
-  args: {
-    // Accept both native and legacy-shaped IDs
-    nodeId: v.optional(v.id("epistemicNodes")),
-    insightId: v.optional(v.string()),
-    text: v.optional(v.string()),
-    kind: v.optional(v.string()),
-    tags: v.optional(v.array(v.string())),
-    userId: v.string(),
-    externalSourceUrl: v.optional(v.string()),
-    verificationStatus: v.optional(v.string())
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const resolvedId = args.nodeId ?? args.insightId;
-    if (!resolvedId) {
-      throw new Error("Either nodeId or insightId is required");
-    }
-    const node = await ctx.db.get(resolvedId);
-    if (!node || node.nodeType !== "evidence") {
-      throw new Error("Evidence node not found");
-    }
-    if (!node.projectId) {
-      throw new Error("Evidence has no project scope");
-    }
-    await checkProjectAccess(ctx, node.projectId, args.userId);
-    const now = Date.now();
-    const existingMeta = node.metadata || {};
-    const metaUpdates = { ...existingMeta };
-    if (args.kind !== void 0) {
-      metaUpdates.kind = args.kind;
-    }
-    if (args.tags !== void 0) {
-      metaUpdates.tags = args.tags;
-    }
-    if (args.externalSourceUrl !== void 0) {
-      metaUpdates.externalSourceUrl = args.externalSourceUrl;
-    }
-    await ctx.db.patch(resolvedId, {
-      canonicalText: args.text ?? node.canonicalText,
-      metadata: metaUpdates,
-      updatedAt: now
-    });
-    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
-      nodeId: resolvedId,
-      operation: "upsert"
-    });
-    await ctx.db.insert("epistemicAudit", {
-      entityType: "evidence",
-      entityId: resolvedId,
-      changeType: "updated",
-      changedAt: now,
-      changedBy: args.userId,
-      isAgent: false,
-      projectId: node.projectId,
-      previousState: { text: node.canonicalText?.slice(0, 200) },
-      newState: { text: (args.text ?? node.canonicalText)?.slice(0, 200) }
-    });
-    if (args.text !== void 0) {
-      await ctx.scheduler.runAfter(
-        0,
-        "embeddingActions:generateEpistemicNodeEmbedding",
-        {
-          nodeId: resolvedId,
-          topicId: node.projectId,
-          createdBy: node.createdBy,
-          nodeType: "evidence",
-          text: args.text
-        }
-      );
-    }
-    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
-    return { nodeId: resolvedId };
-  }
-});
-var flagAsIncorrect = mutation({
-  args: {
-    insightId: v.id("epistemicNodes"),
-    reason: v.string(),
-    suggestedCorrection: v.optional(v.string()),
-    userId: v.string()
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const now = Date.now();
-    const node = await ctx.db.get(args.insightId);
-    if (!node || node.nodeType !== "evidence") {
-      throw new Error("Evidence not found in epistemic spine");
-    }
-    if (!node.projectId) {
-      throw new Error("Evidence has no project scope");
-    }
-    await checkProjectAccess(ctx, node.projectId, args.userId);
-    const existingMeta = node.metadata || {};
-    await ctx.db.patch(node._id, {
-      verificationStatus: "contradicted",
-      metadata: {
-        ...existingMeta,
-        contradictionReason: args.reason,
-        suggestedCorrection: args.suggestedCorrection,
-        contradictedBy: args.userId,
-        contradictedAt: now
-      },
-      updatedAt: now
-    });
-    await ctx.db.insert("verificationResults", {
-      targetType: "insight",
-      targetId: node._id,
-      claimText: node.canonicalText || "Evidence text not available",
-      verdict: "contradicted",
-      confidence: 1,
-      sources: [],
-      reasoning: args.reason,
-      suggestedRevision: args.suggestedCorrection,
-      caveats: [],
-      mode: "deep_verify",
-      verifiedAt: now,
-      durationMs: 0,
-      projectId: node.projectId,
-      userId: args.userId
-    });
-    await ctx.db.insert("epistemicAudit", {
-      entityType: "evidence",
-      entityId: node._id,
-      changeType: "updated",
-      changedAt: now,
-      changedBy: args.userId,
-      isAgent: false,
-      projectId: node.projectId,
-      newState: {
-        reason: args.reason,
-        suggestedCorrection: args.suggestedCorrection
-      }
-    });
-    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
-    console.log(
-      `[EpistemicEvidence] Evidence flagged as incorrect by ${args.userId}: "${args.insightId.slice(0, 20)}..."`
-    );
-    return { success: true };
-  }
-});
-var remove = mutation({
-  args: {
-    // Accept both native and legacy-shaped IDs
-    nodeId: v.optional(v.id("epistemicNodes")),
-    insightId: v.optional(v.string()),
-    userId: v.string()
-  },
-  returns: permissiveReturn,
-  handler: async (ctx, args) => {
-    const resolvedId = args.nodeId ?? args.insightId;
-    if (!resolvedId) {
-      throw new Error("Either nodeId or insightId is required");
-    }
-    const node = await ctx.db.get(resolvedId);
-    if (!node || node.nodeType !== "evidence") {
-      throw new Error("Evidence node not found");
-    }
-    if (node.createdBy !== args.userId) {
-      throw new Error("Only the creator can archive this evidence");
-    }
-    const now = Date.now();
-    await ctx.db.patch(resolvedId, {
-      status: "archived",
-      updatedAt: now
-    });
-    await ctx.scheduler.runAfter(0, internal.neo4jSync.syncNodeToNeo4j, {
-      nodeId: resolvedId,
-      operation: "upsert"
-    });
-    await ctx.db.insert("epistemicAudit", {
-      entityType: "evidence",
-      entityId: resolvedId,
-      changeType: "archived",
-      changedAt: now,
-      changedBy: args.userId,
-      isAgent: false,
-      projectId: node.projectId,
-      previousState: { status: node.status },
-      newState: { status: "archived" }
-    });
-    await markProjectGraphDirty(ctx, node.projectId, node.topicId);
-    return { nodeId: resolvedId };
-  }
-});
 
 export { create, createAndLink, flagAsIncorrect, flattenEvidenceNode, getById, getByProject, getByProjectSystem, getByTopic, getEvidenceBalance, getForBelief, internalCreate, internalGetByProject, internalGetByTopic, remove, resolveEvidenceLinkedWorktreeId, update, updateStatus, updateVerificationStatus };
 //# sourceMappingURL=epistemicEvidence.js.map