@lucern/graph-primitives 1.0.0 → 1.0.1

package/dist/epistemicBeliefs.js

@@ -2,14 +2,14 @@ import { v } from 'convex/values';
 import { normalizeTupleContradictionPolicy, mkOpinion, createInheritedContractRecord, confidenceFromSL, conditionalDeduction, project, dampedDependencyCascade, hasProjectedOpinionChanged, detectTupleContradiction, evaluateTupleContradictionTransition, readOpinionFromRecord, trustDiscount, applyNegativeSupport, cumulativeFusion, applyNegativeEvidence } from '@lucern/confidence';
 import { checkScopeAccess, checkProjectAccess } from '@lucern/access-control/access';
 import { canAudienceClassAccess, normalizeAudienceKey, classFromAudienceKey } from '@lucern/access-control/audience';
-import { listAudienceRegistryRows } from '@lucern/access-control/audienceRegistry';
 import { getCurrentUserId } from '@lucern/access-control/auth';
-import { assertSchemaEnumValue } from '@lucern/contracts/schema-helpers/enumValidation';
-import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
 import { componentsGeneric, anyApi, internalMutationGeneric, mutationGeneric, queryGeneric, internalQueryGeneric } from 'convex/server';
 import { isNodeType, getLayerForNodeType } from '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
+import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
+import { assertSchemaEnumValue } from '@lucern/contracts/schema-helpers/enumValidation';
+import { listAudienceRegistryRows } from '@lucern/access-control/audienceRegistry';
 
-// src/epistemicBeliefs.ts
+// src/epistemicBeliefs.helpers.ts
 
 // src/beliefLifecycle.ts
 var BELIEF_STATUS_VALUES = [
@@ -110,375 +110,417 @@ var internalQuery = internalQueryGeneric;
 var mutation = mutationGeneric;
 var query = queryGeneric;
 
-// src/edges/contains.ts
-var containsPropagationSpec = {
-  edgeType: "contains",
-  direction: "outgoing",
-  transitivity: "none",
-  damping: 1,
-  maxHops: 1,
-  operator: () => null,
-  description: "Structural containment only. Traversed for explicit semantics, but it never propagates opinions."
-};
-function readEdgeMetadata(edge) {
-  return {
-    constraint: edge.constraint ?? void 0,
-    normalization: edge.normalization ?? void 0,
-    propagation: edge.propagation ?? void 0,
-    conditionalA: edge.conditionalA ?? void 0,
-    conditionalNotA: edge.conditionalNotA ?? void 0
-  };
+// src/debug.ts
+function isGraphPrimitiveDebugEnabled() {
+  const env = globalThis.process?.env;
+  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
 }
-function applyPerHopDamping(sourceOpinion, damping) {
-  if (damping >= 1) {
-    return sourceOpinion;
+function debugGraphPrimitiveFallback(message, context) {
+  if (!isGraphPrimitiveDebugEnabled()) {
+    return;
   }
-  return trustDiscount(sourceOpinion, Math.max(0, damping));
+  console.debug(message, context ?? {});
 }
-function annotateRationale(result, spec, hop) {
-  return {
-    ...result,
-    rationale: `hop=${hop} edge=${spec.edgeType} damping=${spec.damping.toFixed(
-      2
-    )} :: ${result.rationale}`
-  };
+
+// 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 propagatePositiveSupport(sourceOpinion, targetOpinion, edgeWeight) {
-  const discounted = trustDiscount(sourceOpinion, Math.abs(edgeWeight));
-  return {
-    opinion: cumulativeFusion(targetOpinion, discounted),
-    operator: "cumulative_fusion",
-    rationale: `Supporting evidence (weight=${edgeWeight.toFixed(
-      2
-    )}) from source at ${project(sourceOpinion).toFixed(2)}`
-  };
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => readNonEmptyString(entry)).filter((entry) => Boolean(entry));
 }
-function propagatePositiveInform(sourceOpinion, targetOpinion, edgeWeight) {
-  const discounted = trustDiscount(sourceOpinion, Math.abs(edgeWeight));
-  return {
-    opinion: cumulativeFusion(targetOpinion, discounted),
-    operator: "cumulative_fusion",
-    rationale: `Supporting evidence (weight=${edgeWeight.toFixed(2)})`
-  };
+function readMetadata(topic) {
+  return topic.metadata && typeof topic.metadata === "object" ? topic.metadata : {};
 }
-function propagateNegativeSupportWithMetadata(sourceOpinion, targetOpinion, edgeWeight, edge) {
-  return applyNegativeSupport(
-    sourceOpinion,
-    targetOpinion,
-    edgeWeight,
-    readEdgeMetadata(edge)
-  );
+function readLegacyProjectId(value) {
+  if (!value) {
+    return;
+  }
+  return readNonEmptyString(value[LEGACY_SCOPE_FIELD]);
 }
-var propagateNegativeInform = applyNegativeEvidence;
-
-// src/edges/contradicts.ts
-var contradictsPropagationSpec = {
-  edgeType: "contradicts",
-  direction: "bidirectional",
-  transitivity: "none",
-  damping: 0.85,
-  maxHops: 1,
-  operator: (sourceOpinion, targetOpinion, edge, context) => {
-    const dampedSource = applyPerHopDamping(
-      sourceOpinion,
-      context.spec.damping
-    );
-    const negativeWeight = -Math.abs(edge.weight ?? 1);
-    const result = propagateNegativeSupportWithMetadata(
-      dampedSource,
-      targetOpinion,
-      negativeWeight,
-      edge
-    );
-    return annotateRationale(result, context.spec, context.hop);
-  },
-  description: "Legacy contradiction edges move negative pressure in either direction, but never beyond one hop."
-};
-var dependsOnPropagationSpec = {
-  edgeType: "depends_on",
-  direction: "incoming",
-  transitivity: "damped",
-  damping: 0.8,
-  maxHops: "unbounded",
-  operator: (sourceOpinion, targetOpinion, edge, context) => {
-    const dampedSource = applyPerHopDamping(
-      sourceOpinion,
-      context.spec.damping
-    );
-    const metadata = readEdgeMetadata(edge);
-    if (metadata.conditionalA && metadata.conditionalNotA) {
-      const deducedOpinion = conditionalDeduction(
-        dampedSource,
-        mkOpinion(
-          metadata.conditionalA.b,
-          metadata.conditionalA.d,
-          metadata.conditionalA.u,
-          metadata.conditionalA.a
-        ),
-        mkOpinion(
-          metadata.conditionalNotA.b,
-          metadata.conditionalNotA.d,
-          metadata.conditionalNotA.u,
-          metadata.conditionalNotA.a
-        ),
-        targetOpinion.a
+function coerceVisibility(value) {
+  return value === "private" || value === "team" || value === "firm" || value === "external" || value === "public" ? value : void 0;
+}
+function coerceStatus(value) {
+  return value === "active" || value === "archived" || value === "watching" ? value : void 0;
+}
+function mapProjectType(topic, metadata) {
+  const explicit = readNonEmptyString(metadata.projectType);
+  if (explicit) {
+    return explicit;
+  }
+  if (topic.type === "theme") {
+    return "thematic";
+  }
+  return readNonEmptyString(topic.type) || "general";
+}
+function isProjectLikeTopic(topic) {
+  const metadata = readMetadata(topic);
+  return topic.type === "theme" || topic.type === "thematic" || topic.type === "deal" || topic.type === "monitoring" || readLegacyProjectId(topic) !== void 0 || readNonEmptyString(metadata.projectType) !== void 0;
+}
+function isMissingLucernChildComponentError(error) {
+  const message = getErrorMessage(error);
+  return message.includes(
+    'Child component ComponentName(Identifier("lucern")) not found'
+  ) || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return "unknown error";
+}
+async function resolveTopicDoc(ctx, scopeId) {
+  if (ctx?.db && typeof ctx.db.get === "function") {
+    try {
+      const directTopic = await ctx.db.get(
+        scopeId
       );
-      return annotateRationale(
+      if (directTopic) {
+        return directTopic;
+      }
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[topicProjectOverlay] Failed to resolve topic by direct ID",
         {
-          opinion: deducedOpinion,
-          operator: "conditional_deduction",
-          rationale: `Conditional deduction: prerequisite at ${project(
-            dampedSource
-          ).toFixed(2)}`
-        },
-        context.spec,
-        context.hop
+          error,
+          scopeId
+        }
       );
     }
-    const result = dampedDependencyCascade(
-      dampedSource,
-      targetOpinion,
-      metadata.propagation ?? "continuous"
-    );
-    return annotateRationale(result, context.spec, context.hop);
-  },
-  description: "Structural gating. Textbook conditional deduction when edge conditionals exist, otherwise damped dependency cascade through downstream chains."
-};
-
-// src/edges/derivedFrom.ts
-var derivedFromPropagationSpec = {
-  edgeType: "derived_from",
-  direction: "incoming",
-  transitivity: "none",
-  damping: 1,
-  maxHops: 1,
-  operator: () => null,
-  description: "Provenance only. The traversal surface stays explicit, but confidence does not move across derived_from edges."
-};
-
-// src/edges/elaborates.ts
-var elaboratesPropagationSpec = {
-  edgeType: "elaborates",
-  direction: "outgoing",
-  transitivity: "damped",
-  damping: 0.7,
-  maxHops: 2,
-  operator: (sourceOpinion, targetOpinion, edge, context) => {
-    const dampedSource = applyPerHopDamping(
-      sourceOpinion,
-      context.spec.damping
-    );
-    const contextualWeight = Math.min(Math.abs(edge.weight ?? 0.35), 0.35);
-    const result = propagatePositiveInform(
-      dampedSource,
-      targetOpinion,
-      contextualWeight
+  }
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    const topic = await ctx.runQuery(api.topics.get, {
+      id: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicProjectOverlay] Failed to resolve topic by ID query",
+      {
+        error,
+        scopeId
+      }
     );
-    return annotateRationale(result, context.spec, context.hop);
-  },
-  description: "Context-rich supporting detail. Elaborates carries a small positive effect with short, damped chaining."
-};
-
-// src/edges/informs.ts
-var informsPropagationSpec = {
-  edgeType: "informs",
-  direction: "outgoing",
-  transitivity: "full",
-  damping: 0.92,
-  maxHops: "unbounded",
-  operator: (sourceOpinion, targetOpinion, edge, context) => {
-    const dampedSource = applyPerHopDamping(
-      sourceOpinion,
-      context.spec.damping
-    );
-    const weight = edge.weight ?? 1;
-    const result = weight < 0 ? propagateNegativeInform(dampedSource, targetOpinion, weight) : propagatePositiveInform(dampedSource, targetOpinion, weight);
-    return annotateRationale(result, context.spec, context.hop);
-  },
-  description: "Evidence-bearing influence. Informs can chain through the graph with light per-hop damping."
-};
-
-// src/edges/propagationTypes.ts
-function isPropagationTraversalDirection(direction) {
-  return direction === "outgoing" || direction === "incoming";
-}
-function canTraverseHop(spec, nextHop) {
-  return spec.maxHops === "unbounded" || nextHop <= spec.maxHops;
-}
-function canContinueTransitively(spec, currentHop) {
-  if (spec.transitivity === "none") {
-    return false;
   }
-  return spec.maxHops === "unbounded" || currentHop < spec.maxHops;
-}
-
-// src/edges/refutes.ts
-var refutesPropagationSpec = {
-  edgeType: "refutes",
-  direction: "outgoing",
-  transitivity: "none",
-  damping: 0.9,
-  maxHops: 1,
-  operator: (sourceOpinion, targetOpinion, edge, context) => {
-    const dampedSource = applyPerHopDamping(
-      sourceOpinion,
-      context.spec.damping
-    );
-    const negativeWeight = -Math.abs(edge.weight ?? 1);
-    const result = propagateNegativeInform(
-      dampedSource,
-      targetOpinion,
-      negativeWeight
-    );
-    return annotateRationale(result, context.spec, context.hop);
-  },
-  description: "Explicit negative evidence semantics. Refutes is treated as strong one-hop counter-evidence."
-};
-
-// src/edges/supports.ts
-var supportsPropagationSpec = {
-  edgeType: "supports",
-  direction: "outgoing",
-  transitivity: "full",
-  damping: 0.85,
-  maxHops: "unbounded",
-  operator: (sourceOpinion, targetOpinion, edge, context) => {
-    const dampedSource = applyPerHopDamping(
-      sourceOpinion,
-      context.spec.damping
+  try {
+    const topic = await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicProjectOverlay] Failed to resolve topic by legacy scope ID",
+      { error, scopeId }
     );
-    const weight = edge.weight ?? 1;
-    const result = weight < 0 ? propagateNegativeSupportWithMetadata(
-      dampedSource,
-      targetOpinion,
-      weight,
-      edge
-    ) : propagatePositiveSupport(dampedSource, targetOpinion, weight);
-    return annotateRationale(result, context.spec, context.hop);
-  },
-  description: "Belief-to-belief influence. Supports chains transitively with moderate per-hop damping."
-};
-
-// src/edges/tests.ts
-var testsPropagationSpec = {
-  edgeType: "tests",
-  direction: "outgoing",
-  transitivity: "none",
-  damping: 1,
-  maxHops: 1,
-  operator: () => null,
-  description: "Interrogation linkage only. Tests edges do not directly move confidence."
-};
-
-// src/edges/index.ts
-var EDGE_PROPAGATION_SPECS = [
-  supportsPropagationSpec,
-  informsPropagationSpec,
-  dependsOnPropagationSpec,
-  derivedFromPropagationSpec,
-  containsPropagationSpec,
-  testsPropagationSpec,
-  contradictsPropagationSpec,
-  refutesPropagationSpec,
-  elaboratesPropagationSpec
-];
-new Map(EDGE_PROPAGATION_SPECS.map((spec) => [spec.edgeType, spec]));
-function getEdgePropagationSpecs() {
-  return EDGE_PROPAGATION_SPECS;
-}
-function getTraversalDirections(direction) {
-  if (isPropagationTraversalDirection(direction)) {
-    return [direction];
   }
-  return ["outgoing", "incoming"];
-}
-
-// src/debug.ts
-function isGraphPrimitiveDebugEnabled() {
-  const env = globalThis.process?.env;
-  return env?.LUCERN_COMPAT_FALLBACK_DEBUG === "1" || env?.LUCERN_GRAPH_DEBUG === "1";
+  return null;
 }
-function debugGraphPrimitiveFallback(message, context) {
-  if (!isGraphPrimitiveDebugEnabled()) {
-    return;
-  }
-  console.debug(message, context ?? {});
+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
+  };
 }
-
-// src/topicScope.ts
-var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
-function asMappedProjectId(topic) {
+async function resolveTopicProjectOverlay(ctx, scopeId, options = {}) {
+  const topic = await resolveTopicDoc(ctx, scopeId);
   if (!topic) {
-    return;
-  }
-  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
-  if (directLegacyProjectId) {
-    return directLegacyProjectId;
+    return null;
   }
-  const metadata = topic.metadata || {};
-  const candidate = metadata[LEGACY_SCOPE_FIELD] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
-  return candidate ? candidate : void 0;
-}
-function normalizeScopeValue(value) {
-  if (typeof value !== "string") {
-    return;
+  if (options.projectLikeOnly !== false && !isProjectLikeTopic(topic)) {
+    return null;
   }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : void 0;
+  return materializeTopicProjectOverlay(topic, options.idMode);
 }
-function pickPrimaryTopic(candidates) {
-  return [...candidates].sort((a, b) => {
-    const depthA = a.depth ?? 9999;
-    const depthB = b.depth ?? 9999;
-    if (depthA !== depthB) {
-      return depthA - depthB;
-    }
-    const createdA = a.createdAt ?? Number.MAX_SAFE_INTEGER;
-    const createdB = b.createdAt ?? Number.MAX_SAFE_INTEGER;
-    if (createdA !== createdB) {
-      return createdA - createdB;
+async function listTopicProjectOverlays(ctx, options = {}) {
+  let allTopics = [];
+  if (ctx?.db?.query && typeof ctx.db.query === "function") {
+    try {
+      allTopics = await ctx.db.query("topics").collect();
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[topicProjectOverlay] Failed to read topics table; falling back to API",
+        { error }
+      );
+      allTopics = [];
     }
-    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_FIELD, scopeId)
-    ).collect();
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve scope alias via index",
-      {
-        error,
-        scopeId
-      }
-    );
-    const topics = await ctx.db.query("topics").collect();
-    return topics.filter((topic) => {
-      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
-      const mappedProjectId = asMappedProjectId(topic);
-      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
-    });
   }
+  if (allTopics.length === 0 && typeof ctx.runQuery === "function") {
+    allTopics = (await ctx.runQuery(api.topics.list, {}) ?? []) || [];
+  }
+  return allTopics.filter(
+    (topic) => options.projectLikeOnly === false || isProjectLikeTopic(topic)
+  ).map((topic) => materializeTopicProjectOverlay(topic, options.idMode));
 }
-async function tryResolveHostTopicById(ctx, topicId) {
-  if (typeof ctx.runQuery !== "function") {
+async function patchTopicProjectOverlay(ctx, scopeId, value) {
+  const topic = await resolveTopicDoc(ctx, scopeId);
+  if (!topic) {
     return null;
   }
-  try {
-    return await ctx.runQuery(api.topics.get, {
-      id: topicId
-    }) ?? null;
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicScope] Failed to resolve topic by host query",
-      {
-        error,
-        topicId
-      }
-    );
+  const nextMetadata = { ...readMetadata(topic) };
+  const patch = {};
+  const topicUpdateArgs = {
+    id: String(topic._id)
+  };
+  for (const [key, rawValue] of Object.entries(value)) {
+    switch (key) {
+      case "_id":
+      case "projectId":
+      case "topicId":
+      case "legacyProjectId":
+      case "storageProjectId":
+        break;
+      case "name":
+      case "description":
+        patch[key] = rawValue;
+        topicUpdateArgs[key] = rawValue;
+        break;
+      case "tenantId":
+      case "workspaceId":
+      case "ownerId":
+        throw new Error(
+          `patchTopicProjectOverlay cannot mutate ${key} via component-owned topics`
+        );
+      case "status": {
+        const status = coerceStatus(rawValue);
+        if (status) {
+          patch.status = status;
+          topicUpdateArgs.status = status;
+        }
+        break;
+      }
+      case "visibility": {
+        const visibility = coerceVisibility(rawValue);
+        if (visibility) {
+          patch.visibility = visibility;
+          topicUpdateArgs.visibility = visibility;
+        }
+        break;
+      }
+      case "type": {
+        const projectType = readNonEmptyString(rawValue);
+        if (projectType) {
+          nextMetadata.projectType = projectType;
+        } else {
+          delete nextMetadata.projectType;
+        }
+        break;
+      }
+      case "updatedAt":
+      case "createdAt":
+        break;
+      default:
+        if (rawValue === void 0) {
+          delete nextMetadata[key];
+        } else {
+          nextMetadata[key] = rawValue;
+        }
+    }
+  }
+  patch.updatedAt = Date.now();
+  patch.metadata = nextMetadata;
+  topicUpdateArgs.metadata = nextMetadata;
+  if (typeof ctx.runMutation === "function") {
+    try {
+      await ctx.runMutation(api.topics.update, topicUpdateArgs);
+    } catch (error) {
+      if (!isMissingLucernChildComponentError(error) || !ctx?.db || typeof ctx.db.patch !== "function") {
+        throw error;
+      }
+      await ctx.db.patch(String(topic._id), patch);
+    }
+  } else if (ctx?.db && typeof ctx.db.patch === "function") {
+    await ctx.db.patch(String(topic._id), patch);
+  } else {
+    throw new Error(
+      "Cannot patch topic without component adapter (ctx.runMutation unavailable)"
+    );
+  }
+  return materializeTopicProjectOverlay({
+    ...topic,
+    ...patch,
+    metadata: nextMetadata
+  });
+}
+
+// src/resolvers.ts
+function isMissingLucernChildComponentError2(error) {
+  const message = getErrorMessage2(error);
+  return message.includes(
+    'Child component ComponentName(Identifier("lucern")) not found'
+  ) || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
+}
+function getErrorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
+  }
+  return "unknown error";
+}
+function isAdvisoryTopicPatch(value) {
+  const advisoryKeys = /* @__PURE__ */ new Set(["lastActivityAt", "updatedAt"]);
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((key) => advisoryKeys.has(key));
+}
+async function patchProjectWithTolerance(ctx, projectId, value) {
+  try {
+    await patchTopicProjectOverlay(ctx, projectId, value);
+  } catch (error) {
+    if (!isAdvisoryTopicPatch(value) || !isMissingLucernChildComponentError2(error)) {
+      throw error;
+    }
+    console.warn(
+      "[lucern graph-primitives] Non-fatal advisory topic patch failure",
+      {
+        projectId,
+        keys: Object.keys(value),
+        error: getErrorMessage2(error)
+      }
+    );
+  }
+}
+function defaultResolvers() {
+  return {
+    getProject: (ctx, projectId) => resolveTopicProjectOverlay(ctx, projectId, {
+      idMode: "legacy",
+      projectLikeOnly: false
+    }),
+    patchProject: (ctx, projectId, value) => patchProjectWithTolerance(ctx, projectId, value),
+    listTopics: (ctx) => listTopicProjectOverlays(ctx, {
+      idMode: "legacy"
+    }),
+    getFinalArtifact: (ctx, artifactId) => ctx.db.get(artifactId)
+  };
+}
+var resolverOverrides = {};
+function resolveGraphPrimitivesAppResolvers(_ctx) {
+  return {
+    ...defaultResolvers(),
+    ...resolverOverrides
+  };
+}
+var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
+function asMappedProjectId(topic) {
+  if (!topic) {
+    return;
+  }
+  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD2]);
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
+  }
+  const metadata = topic.metadata || {};
+  const candidate = metadata[LEGACY_SCOPE_FIELD2] || metadata.legacyProjectId || metadata.projectId || metadata.scopeProjectId;
+  return candidate ? candidate : void 0;
+}
+function normalizeScopeValue(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function pickPrimaryTopic(candidates) {
+  return [...candidates].sort((a, b) => {
+    const depthA = a.depth ?? 9999;
+    const depthB = b.depth ?? 9999;
+    if (depthA !== depthB) {
+      return depthA - depthB;
+    }
+    const createdA = a.createdAt ?? Number.MAX_SAFE_INTEGER;
+    const createdB = b.createdAt ?? Number.MAX_SAFE_INTEGER;
+    if (createdA !== createdB) {
+      return createdA - createdB;
+    }
+    return String(a.name || "").localeCompare(String(b.name || ""));
+  })[0];
+}
+async function findTopicsByScopeAlias(ctx, scopeId) {
+  try {
+    return await ctx.db.query("topics").withIndex(
+      "by_graph_scope_project",
+      (q) => q.eq(LEGACY_SCOPE_FIELD2, scopeId)
+    ).collect();
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve scope alias via index",
+      {
+        error,
+        scopeId
+      }
+    );
+    const topics = await ctx.db.query("topics").collect();
+    return topics.filter((topic) => {
+      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
+      const mappedProjectId = asMappedProjectId(topic);
+      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
+    });
+  }
+}
+async function tryResolveHostTopicById(ctx, topicId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.get, {
+      id: topicId
+    }) ?? null;
+  } catch (error) {
+    debugGraphPrimitiveFallback(
+      "[topicScope] Failed to resolve topic by host query",
+      {
+        error,
+        topicId
+      }
+    );
     return null;
   }
 }
@@ -629,8 +671,6 @@ var optionalScopeArgs = {
   projectId: v.optional(v.string()),
   topicId: v.optional(v.string())
 };
-
-// src/workspaceIsolation.ts
 function normalizeScopeValue2(value) {
   if (typeof value !== "string") {
     return;
@@ -780,896 +820,786 @@ function assertTenantPackWorkspaceMutationAllowed(args) {
   });
 }
 
-// src/confidencePropagationDispatch.ts
-function resolveTraversalTargetNodeId(edge, direction) {
-  const targetNodeId = direction === "outgoing" ? edge.toNodeId : edge.fromNodeId;
-  return targetNodeId ?? void 0;
+// src/epistemicBeliefs.helpers.ts
+var insightIdUnion = v.id("epistemicNodes");
+var DEFAULT_PROJECT_BELIEF_LIMIT = 250;
+var MAX_PROJECT_BELIEF_LIMIT = 1e3;
+var optionalBeliefScopeArgs = optionalScopeArgs;
+var DEFAULT_CONFIDENCE_POLICY = {
+  scoringMode: "after_worktree",
+  tupleContradiction: normalizeTupleContradictionPolicy()
+};
+function throwStructuredMutationError(args) {
+  const error = new Error(args.message);
+  error.status = args.status;
+  error.code = args.code;
+  error.invariantCode = args.invariantCode;
+  error.suggestion = args.suggestion;
+  error.details = args.details;
+  throw error;
 }
-function readNodeOpinion(node) {
-  const metadata = node.metadata ?? {};
-  try {
-    return readOpinionFromRecord({
-      ...metadata,
-      opinion_b: node.opinion_b,
-      opinion_d: node.opinion_d,
-      opinion_u: node.opinion_u,
-      opinion_a: node.opinion_a
-    });
-  } catch {
-    return mkOpinion(0, 0, 1, 0.5);
-  }
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-async function collectConfidencePropagationDispatches(args) {
-  const dispatchesByTargetId = /* @__PURE__ */ new Map();
-  const opinionCache = /* @__PURE__ */ new Map();
-  const nodeCache = /* @__PURE__ */ new Map();
-  const traversalSpecs = args.traversalSpecs ?? getEdgePropagationSpecs();
-  const queue = [
-    {
-      nodeId: args.sourceNodeId,
-      opinion: args.sourceOpinion,
-      hop: 0,
-      visitedNodeIds: /* @__PURE__ */ new Set([String(args.sourceNodeId)])
-    }
-  ];
-  const loadNode = async (nodeId) => {
-    const cacheKey = String(nodeId);
-    if (!nodeCache.has(cacheKey)) {
-      nodeCache.set(cacheKey, await args.getNode(nodeId));
-    }
-    return nodeCache.get(cacheKey) ?? null;
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function assertBaseRateInRange(baseRate, field = "baseRate") {
+  if (baseRate < 0 || baseRate > 1) {
+    throwStructuredMutationError({
+      message: `${field} must be within [0, 1].`,
+      status: 400,
+      code: "INVALID_ARGUMENT",
+      invariantCode: "request.valid_shape",
+      suggestion: `Clamp ${field} into the inclusive [0, 1] interval.`,
+      details: { field, baseRate }
+    });
+  }
+  return baseRate;
+}
+function buildBeliefConfidenceRow(args) {
+  return {
+    beliefId: args.beliefId,
+    confidence: confidenceFromSL(
+      args.belief,
+      args.disbelief,
+      args.uncertainty,
+      args.baseRate
+    ),
+    belief: args.belief,
+    disbelief: args.disbelief,
+    uncertainty: args.uncertainty,
+    baseRate: args.baseRate,
+    slOperator: args.slOperator ?? "manual_assessment",
+    trigger: args.trigger,
+    ...args.rationale ? { rationale: args.rationale } : {},
+    assessedBy: args.assessedBy,
+    assessedAt: args.assessedAt,
+    ...args.triggeringEvidenceId ? {
+      triggeringEvidenceId: args.triggeringEvidenceId,
+      triggeringEvidenceIds: [String(args.triggeringEvidenceId)]
+    } : {},
+    ...args.triggeringContradictionId ? {
+      triggeringContradictionId: args.triggeringContradictionId
+    } : {},
+    ...args.triggeringWorktreeId ? { triggeringWorktreeId: args.triggeringWorktreeId } : {}
   };
-  while (queue.length > 0) {
-    const state = queue.shift();
-    if (!state) {
-      continue;
-    }
-    for (const spec of traversalSpecs) {
-      const nextHop = state.hop + 1;
-      if (!canTraverseHop(spec, nextHop)) {
-        continue;
-      }
-      for (const direction of getTraversalDirections(spec.direction)) {
-        const edges = await args.queryEdges({
-          nodeId: state.nodeId,
-          spec,
-          direction,
-          hop: nextHop
-        });
-        for (const edge of edges) {
-          if (args.sourceScope && !edgeMatchesWorkspaceReasoningScope(edge, args.sourceScope)) {
-            continue;
-          }
-          const targetNodeId = resolveTraversalTargetNodeId(edge, direction);
-          if (!targetNodeId) {
-            continue;
-          }
-          if (state.visitedNodeIds.has(String(targetNodeId))) {
-            continue;
-          }
-          const targetNode = await loadNode(targetNodeId);
-          if (!targetNode || targetNode.nodeType !== "belief") {
-            continue;
-          }
-          if (args.sourceScope && !nodeMatchesWorkspaceReasoningScope(targetNode, args.sourceScope)) {
-            continue;
-          }
-          const cacheKey = String(targetNodeId);
-          const targetOpinion = opinionCache.get(cacheKey) ?? readNodeOpinion(targetNode);
-          const result = spec.operator(state.opinion, targetOpinion, edge, {
-            hop: nextHop,
-            sourceNodeId: state.nodeId,
-            targetNodeId,
-            traversedDirection: direction,
-            spec
-          });
-          if (!result || !hasProjectedOpinionChanged(targetOpinion, result.opinion)) {
-            continue;
-          }
-          const projectedOpinion = mkOpinion(
-            result.opinion.b,
-            result.opinion.d,
-            result.opinion.u,
-            result.opinion.a
-          );
-          opinionCache.set(cacheKey, projectedOpinion);
-          const existingDispatch = dispatchesByTargetId.get(cacheKey);
-          dispatchesByTargetId.set(cacheKey, {
-            targetNodeId,
-            edgeType: spec.edgeType,
-            traversedDirection: direction,
-            weight: edge.weight ?? 1,
-            opinion: projectedOpinion,
-            operator: result.operator,
-            rationale: existingDispatch ? `${existingDispatch.rationale}; ${result.rationale}` : result.rationale,
-            hop: nextHop
-          });
-          if (canContinueTransitively(spec, nextHop)) {
-            queue.push({
-              nodeId: targetNodeId,
-              opinion: projectedOpinion,
-              hop: nextHop,
-              visitedNodeIds: /* @__PURE__ */ new Set([
-                ...state.visitedNodeIds,
-                String(targetNodeId)
-              ])
-            });
-          }
+}
+function buildBeliefStatusSuccessResult() {
+  return { success: true };
+}
+function buildBeliefEvidenceNotFoundResult() {
+  const result = {};
+  result.success = false;
+  result.message = "Evidence node not found";
+  return result;
+}
+function deriveSyntheticBackfillOpinion(source) {
+  const belief = readFiniteNumber(source.opinion_b) ?? readFiniteNumber(source.belief);
+  const disbelief = readFiniteNumber(source.opinion_d) ?? readFiniteNumber(source.disbelief);
+  const uncertainty = readFiniteNumber(source.opinion_u) ?? readFiniteNumber(source.uncertainty);
+  const baseRate = readFiniteNumber(source.opinion_a) ?? readFiniteNumber(source.baseRate);
+  if (belief !== void 0 || disbelief !== void 0 || uncertainty !== void 0 || baseRate !== void 0) {
+    try {
+      return readOpinionFromRecord(source);
+    } catch (error) {
+      debugGraphPrimitiveFallback(
+        "[epistemicBeliefs] Failed to decode legacy belief opinion",
+        {
+          error
         }
-      }
+      );
+      return mkOpinion(0, 0, 1, 0.5);
     }
   }
-  return Array.from(dispatchesByTargetId.values()).sort((left, right) => {
-    if (left.hop !== right.hop) {
-      return left.hop - right.hop;
-    }
-    return String(left.targetNodeId).localeCompare(String(right.targetNodeId));
-  });
+  const confidence = clamp01(readFiniteNumber(source.confidence) ?? 0);
+  return mkOpinion(confidence, 1 - confidence, 0, 0.5);
 }
-
-// src/embeddingTrigger.ts
-async function scheduleEmbeddingGeneration(args) {
+function clampBeliefLimit(limit, fallback = DEFAULT_PROJECT_BELIEF_LIMIT) {
+  if (!Number.isFinite(limit)) {
+    return fallback;
+  }
+  return Math.max(
+    1,
+    Math.min(Math.floor(limit), MAX_PROJECT_BELIEF_LIMIT)
+  );
+}
+function readTupleContradictedFlag(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function readBeliefOpinionSnapshot(node, metadata) {
   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
-      }
-    );
+    return readOpinionFromRecord({
+      ...metadata,
+      opinion_b: node.opinion_b,
+      opinion_d: node.opinion_d,
+      opinion_u: node.opinion_u,
+      opinion_a: node.opinion_a
+    });
   } catch (error) {
     debugGraphPrimitiveFallback(
-      "[embeddingTrigger] Failed to schedule embedding generation",
+      "[epistemicBeliefs] Failed to read belief opinion snapshot",
       {
         error,
-        nodeId: String(args.nodeId),
-        nodeType: args.nodeType
+        beliefId: node._id
       }
     );
+    return mkOpinion(0, 0, 1, 0.5);
   }
 }
-
-// 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/logicalRoleInference.ts
-var PILLAR_IMPORTANCE = {
-  market: 1,
-  competition: 2,
-  product: 3,
-  team: 4,
-  financials: 5,
-  timing: 6,
-  other: 10
-};
-async function computeLogicalRole(ctx, evidenceId, beliefId) {
-  const belief = await ctx.db.get(beliefId);
-  if (!belief || belief.nodeType !== "belief") {
-    return "contributory";
+function deriveTupleContradictionSeverity(node) {
+  const metadata = node.metadata || {};
+  const criticality = typeof metadata.criticality === "string" ? metadata.criticality : void 0;
+  if (criticality === "blocking") {
+    return "critical";
   }
-  const beliefMetadata = belief.metadata;
-  const pillar = beliefMetadata?.pillar || "other";
-  const pillarRank = PILLAR_IMPORTANCE[pillar] ?? 10;
-  const isSynthesized = await checkIfSynthesizedHypothesis(ctx, beliefId);
-  const testingQuestions = await getTestingQuestionsForBelief(ctx, beliefId);
-  const answeredQuestions = await getQuestionsAnsweredByEvidence(
-    ctx,
-    evidenceId
-  );
-  const directlyTests = testingQuestions.filter(
-    (questionId) => answeredQuestions.includes(questionId)
-  );
-  if (directlyTests.length === 0) {
-    return "contributory";
+  if (criticality === "supporting") {
+    return "minor";
   }
-  if (isSynthesized && pillarRank <= 2) {
-    return directlyTests.length > 1 ? "necessary_sufficient" : "necessary";
-  }
-  if (isSynthesized) {
-    return "necessary";
-  }
-  return directlyTests.length > 1 ? "necessary" : "contributory";
-}
-async function checkIfSynthesizedHypothesis(ctx, beliefId) {
-  const belief = await ctx.db.get(beliefId);
-  if (!belief) {
-    return false;
-  }
-  const metadata = belief.metadata;
-  return metadata?.isSynthesized === true || metadata?.beliefStatus === "hypothesis";
-}
-async function getTestingQuestionsForBelief(ctx, beliefId) {
-  const testEdges = await ctx.db.query("epistemicEdges").withIndex(
-    "by_to_type",
-    (q) => q.eq("toNodeId", beliefId).eq("edgeType", "tests")
-  ).collect();
-  return testEdges.map((edge) => edge.fromNodeId).filter((id) => id !== void 0);
+  return "significant";
 }
-async function getQuestionsAnsweredByEvidence(ctx, evidenceId) {
-  const answerEdges = await ctx.db.query("epistemicEdges").withIndex(
-    "by_from_type",
-    (q) => q.eq("fromNodeId", evidenceId).eq("edgeType", "derived_from")
-  ).collect();
-  return answerEdges.map((edge) => edge.toNodeId).filter((id) => id !== void 0);
+function formatTupleContradictionDescription(args) {
+  return `Tuple-space contradiction detected: b=${args.opinion.b.toFixed(2)} > ${args.policy.beliefThreshold.toFixed(2)} and d=${args.opinion.d.toFixed(2)} > ${args.policy.disbeliefThreshold.toFixed(2)}.`;
 }
-
-// src/topicProjectOverlay.ts
-var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
-function readNonEmptyString(value) {
-  if (typeof value !== "string") {
-    return;
+function generateContentHash(text) {
+  const content = `belief:${text.trim().toLowerCase().replace(/\s+/g, " ")}`;
+  let hash = 5381;
+  for (let i = 0; i < content.length; i++) {
+    hash = (hash << 5) + hash + content.charCodeAt(i);
+    hash &= hash;
   }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : void 0;
+  return Math.abs(hash).toString(16).padStart(8, "0");
 }
-function readStringArray(value) {
-  if (!Array.isArray(value)) {
-    return [];
+function resolveBeliefWorktreeId(metadata) {
+  const worktreeId = metadata?.worktreeId;
+  if (typeof worktreeId === "string" && worktreeId.trim().length > 0) {
+    return worktreeId;
   }
-  return value.map((entry) => readNonEmptyString(entry)).filter((entry) => Boolean(entry));
-}
-function readMetadata(topic) {
-  return topic.metadata && typeof topic.metadata === "object" ? topic.metadata : {};
+  const sprintId = metadata?.sprintId;
+  return typeof sprintId === "string" && sprintId.trim().length > 0 ? sprintId : void 0;
 }
-function readLegacyProjectId(value) {
-  if (!value) {
-    return;
+function normalizePillar(pillar) {
+  if (!pillar) {
+    return "other";
   }
-  return readNonEmptyString(value[LEGACY_SCOPE_FIELD2]);
-}
-function coerceVisibility(value) {
-  return value === "private" || value === "team" || value === "firm" || value === "external" || value === "public" ? value : void 0;
-}
-function coerceStatus(value) {
-  return value === "active" || value === "archived" || value === "watching" ? value : void 0;
+  const lower = pillar.toLowerCase();
+  const validPillars = [
+    "market",
+    "competition",
+    "product",
+    "team",
+    "financials",
+    "regulatory",
+    "timing",
+    "customer",
+    "technology",
+    "distribution",
+    "deal",
+    "risks"
+  ];
+  return validPillars.find((p) => lower.includes(p)) || "other";
 }
-function mapProjectType(topic, metadata) {
-  const explicit = readNonEmptyString(metadata.projectType);
-  if (explicit) {
-    return explicit;
-  }
-  if (topic.type === "theme") {
-    return "thematic";
+async function markBeliefGraphDirty(ctx, scope) {
+  const projectId = typeof scope.projectId === "string" && scope.projectId.trim().length > 0 ? scope.projectId : void 0;
+  const topicId = typeof scope.topicId === "string" && scope.topicId.trim().length > 0 ? scope.topicId : void 0;
+  if (!projectId && !topicId) {
+    return;
   }
-  return readNonEmptyString(topic.type) || "general";
-}
-function isProjectLikeTopic(topic) {
-  const metadata = readMetadata(topic);
-  return topic.type === "theme" || topic.type === "thematic" || topic.type === "deal" || topic.type === "monitoring" || readLegacyProjectId(topic) !== void 0 || readNonEmptyString(metadata.projectType) !== void 0;
-}
-function isMissingLucernChildComponentError(error) {
-  const message = getErrorMessage(error);
-  return message.includes(
-    'Child component ComponentName(Identifier("lucern")) not found'
-  ) || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
-}
-function getErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
+  if (projectId) {
+    await ctx.scheduler.runAfter(
+      0,
+      internal.graphAnalysisCache.markCacheStaleInternal,
+      { projectId }
+    );
   }
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message;
+  if (topicId) {
+    await ctx.scheduler.runAfter(
+      0,
+      internal.graphAnalysisCache.markCacheStaleByTopic,
+      { topicId }
+    );
   }
-  return "unknown error";
-}
-async function resolveTopicDoc(ctx, scopeId) {
-  if (ctx?.db && typeof ctx.db.get === "function") {
-    try {
-      const directTopic = await ctx.db.get(
-        scopeId
-      );
-      if (directTopic) {
-        return directTopic;
-      }
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicProjectOverlay] Failed to resolve topic by direct ID",
-        {
-          error,
-          scopeId
-        }
-      );
+  await resolveGraphPrimitivesAppResolvers().patchProject(
+    ctx,
+    topicId ?? projectId,
+    {
+      lastActivityAt: Date.now()
     }
-  }
-  if (typeof ctx.runQuery !== "function") {
+  );
+}
+async function resolveBeliefScopeOrNull(ctx, args) {
+  if (!args.projectId && !args.topicId) {
     return null;
   }
   try {
-    const topic = await ctx.runQuery(api.topics.get, {
-      id: String(scopeId)
+    return await resolveTopicProjectScope(ctx, {
+      projectId: args.projectId ?? void 0,
+      topicId: args.topicId ?? void 0
     });
-    if (topic?.name !== void 0 && topic?.type !== void 0) {
-      return topic;
-    }
   } catch (error) {
     debugGraphPrimitiveFallback(
-      "[topicProjectOverlay] Failed to resolve topic by ID query",
+      "[epistemicBeliefs] Failed to resolve belief scope",
       {
         error,
-        scopeId
+        projectId: args.projectId,
+        topicId: args.topicId
       }
     );
+    return null;
   }
-  try {
-    const topic = await ctx.runQuery(api.topics.getByLegacyScopeId, {
-      projectId: String(scopeId)
-    });
-    if (topic?.name !== void 0 && topic?.type !== void 0) {
-      return topic;
-    }
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[topicProjectOverlay] Failed to resolve topic by legacy scope ID",
-      { error, scopeId }
-    );
+}
+async function getBeliefNodesForScope(ctx, scope, args) {
+  const baseQuery = ctx.db.query("epistemicNodes").withIndex(
+    "by_topic_type",
+    (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
+  );
+  const nodes = typeof args?.scanLimit === "number" ? await baseQuery.order("desc").take(args.scanLimit) : await baseQuery.collect();
+  const scopedNodes = nodes.filter(
+    (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
+  );
+  if (!args?.status) {
+    return scopedNodes;
   }
-  return null;
+  return scopedNodes.filter((node) => node.status === args.status);
 }
-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
+function createBeliefAudienceResolver(registryRows) {
+  const audienceClassByKey = new Map(
+    registryRows.map((row) => [
+      normalizeAudienceKey(row.audienceKey),
+      row.audienceClass
+    ])
+  );
+  return (audienceKey, fallback) => {
+    const key = normalizeAudienceKey(audienceKey);
+    if (!key) {
+      return fallback;
+    }
+    return audienceClassByKey.get(key) ?? classFromAudienceKey(key, fallback);
   };
 }
-async function resolveTopicProjectOverlay(ctx, scopeId, options = {}) {
-  const topic = await resolveTopicDoc(ctx, scopeId);
-  if (!topic) {
-    return null;
-  }
-  if (options.projectLikeOnly !== false && !isProjectLikeTopic(topic)) {
-    return null;
-  }
-  return materializeTopicProjectOverlay(topic, options.idMode);
-}
-async function listTopicProjectOverlays(ctx, options = {}) {
-  let allTopics = [];
-  if (ctx?.db?.query && typeof ctx.db.query === "function") {
-    try {
-      allTopics = await ctx.db.query("topics").collect();
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[topicProjectOverlay] Failed to read topics table; falling back to API",
-        { error }
-      );
-      allTopics = [];
-    }
-  }
-  if (allTopics.length === 0 && typeof ctx.runQuery === "function") {
-    allTopics = (await ctx.runQuery(api.topics.list, {}) ?? []) || [];
-  }
-  return allTopics.filter(
-    (topic) => options.projectLikeOnly === false || isProjectLikeTopic(topic)
-  ).map((topic) => materializeTopicProjectOverlay(topic, options.idMode));
-}
-async function patchTopicProjectOverlay(ctx, scopeId, value) {
-  const topic = await resolveTopicDoc(ctx, scopeId);
-  if (!topic) {
-    return null;
-  }
-  const nextMetadata = { ...readMetadata(topic) };
-  const patch = {};
-  const topicUpdateArgs = {
-    id: String(topic._id)
+function flattenBeliefNode(node) {
+  const meta = node.metadata || {};
+  const worktreeId = resolveBeliefWorktreeId(meta);
+  const tupleContradicted = readTupleContradictedFlag(
+    node.tupleContradicted
+  ) ?? readTupleContradictedFlag(meta.tupleContradicted) ?? false;
+  return {
+    _id: node._id,
+    _epistemicNodeId: node._id,
+    _creationTime: node._creationTime,
+    belief: node.canonicalText,
+    formulation: node.canonicalText,
+    projectId: node.projectId,
+    topicId: node.topicId,
+    userId: node.userId || node.createdBy || "",
+    confidence: meta.confidence || "untested",
+    status: node.status,
+    beliefStatus: resolveBeliefStatus(node, meta),
+    topic: meta.topic || meta.pillar || "other",
+    pillar: meta.pillar || meta.topic || "",
+    category: meta.category || "",
+    subcategory: meta.subcategory || "",
+    categoryIcon: meta.categoryIcon || "",
+    supportingEvidence: meta.supportingEvidenceIds || [],
+    contradictingEvidence: meta.contradictingEvidenceIds || [],
+    testingQuestions: meta.testingQuestionIds || [],
+    linkedInsights: meta.linkedInsightIds || [],
+    createdAt: node.createdAt,
+    updatedAt: node.updatedAt || node.createdAt,
+    tupleContradicted,
+    sprintId: meta.sprintId || void 0,
+    worktreeId,
+    sourceBeliefIds: meta.sourceBeliefIds || void 0,
+    criticality: meta.criticality || "unanalyzed",
+    rationale: meta.rationale || "",
+    audienceLabel: node.audienceLabel,
+    policyTags: node.policyTags,
+    sensitivityTier: node.sensitivityTier,
+    exportClass: node.exportClass,
+    anonymizationClass: node.anonymizationClass
   };
-  for (const [key, rawValue] of Object.entries(value)) {
-    switch (key) {
-      case "_id":
-      case "projectId":
-      case "topicId":
-      case "legacyProjectId":
-      case "storageProjectId":
-        break;
-      case "name":
-      case "description":
-        patch[key] = rawValue;
-        topicUpdateArgs[key] = rawValue;
-        break;
-      case "tenantId":
-      case "workspaceId":
-      case "ownerId":
-        throw new Error(
-          `patchTopicProjectOverlay cannot mutate ${key} via component-owned topics`
-        );
-      case "status": {
-        const status = coerceStatus(rawValue);
-        if (status) {
-          patch.status = status;
-          topicUpdateArgs.status = status;
-        }
-        break;
-      }
-      case "visibility": {
-        const visibility = coerceVisibility(rawValue);
-        if (visibility) {
-          patch.visibility = visibility;
-          topicUpdateArgs.visibility = visibility;
-        }
-        break;
-      }
-      case "type": {
-        const projectType = readNonEmptyString(rawValue);
-        if (projectType) {
-          nextMetadata.projectType = projectType;
-        } else {
-          delete nextMetadata.projectType;
-        }
-        break;
-      }
-      case "updatedAt":
-      case "createdAt":
-        break;
-      default:
-        if (rawValue === void 0) {
-          delete nextMetadata[key];
-        } else {
-          nextMetadata[key] = rawValue;
-        }
-    }
-  }
-  patch.updatedAt = Date.now();
-  patch.metadata = nextMetadata;
-  topicUpdateArgs.metadata = nextMetadata;
-  if (typeof ctx.runMutation === "function") {
-    try {
-      await ctx.runMutation(api.topics.update, topicUpdateArgs);
-    } catch (error) {
-      if (!isMissingLucernChildComponentError(error) || !ctx?.db || typeof ctx.db.patch !== "function") {
-        throw error;
-      }
-      await ctx.db.patch(String(topic._id), patch);
-    }
-  } else if (ctx?.db && typeof ctx.db.patch === "function") {
-    await ctx.db.patch(String(topic._id), patch);
-  } else {
-    throw new Error(
-      "Cannot patch topic without component adapter (ctx.runMutation unavailable)"
-    );
-  }
-  return materializeTopicProjectOverlay({
-    ...topic,
-    ...patch,
-    metadata: nextMetadata
-  });
 }
-
-// src/resolvers.ts
-function isMissingLucernChildComponentError2(error) {
-  const message = getErrorMessage2(error);
-  return message.includes(
-    'Child component ComponentName(Identifier("lucern")) not found'
-  ) || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
+function resolveBeliefStatus(node, metadata) {
+  return resolveBeliefLifecycleStatus({
+    beliefStatus: node.beliefStatus,
+    confidence: node.confidence,
+    predictionMeta: node.predictionMeta,
+    metadata
+  });
 }
-function getErrorMessage2(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message;
+async function hasCompletedWorktreeForBelief(ctx, beliefNodeId) {
+  const clusterMembership = await ctx.db.query("worktreeBeliefCluster").withIndex("by_belief", (q) => q.eq("beliefId", beliefNodeId)).collect();
+  for (const membership of clusterMembership) {
+    const worktree = await ctx.db.get(membership.worktreeId);
+    if (worktree?.status === "completed" || worktree?.status === "merged") {
+      return true;
+    }
   }
-  return "unknown error";
-}
-function isAdvisoryTopicPatch(value) {
-  const advisoryKeys = /* @__PURE__ */ new Set(["lastActivityAt", "updatedAt"]);
-  const keys = Object.keys(value);
-  return keys.length > 0 && keys.every((key) => advisoryKeys.has(key));
+  return false;
 }
-async function patchProjectWithTolerance(ctx, projectId, value) {
+async function getActiveConfidencePolicy(ctx) {
   try {
-    await patchTopicProjectOverlay(ctx, projectId, value);
+    const activeConfig = await ctx.db.query("logicSprintScoring").withIndex("by_active", (q) => q.eq("isActive", true)).first();
+    return {
+      scoringMode: activeConfig?.confidencePolicy === "always" ? "always" : DEFAULT_CONFIDENCE_POLICY.scoringMode,
+      tupleContradiction: normalizeTupleContradictionPolicy(
+        activeConfig?.tupleContradictionPolicy
+      )
+    };
   } catch (error) {
-    if (!isAdvisoryTopicPatch(value) || !isMissingLucernChildComponentError2(error)) {
-      throw error;
-    }
-    console.warn(
-      "[lucern graph-primitives] Non-fatal advisory topic patch failure",
+    debugGraphPrimitiveFallback(
+      "[epistemicBeliefs] Failed to load active confidence policy",
       {
-        projectId,
-        keys: Object.keys(value),
-        error: getErrorMessage2(error)
+        error
       }
     );
+    return DEFAULT_CONFIDENCE_POLICY;
   }
 }
-function defaultResolvers() {
-  return {
-    getProject: (ctx, projectId) => resolveTopicProjectOverlay(ctx, projectId, {
-      idMode: "legacy",
-      projectLikeOnly: false
-    }),
-    patchProject: (ctx, projectId, value) => patchProjectWithTolerance(ctx, projectId, value),
-    listTopics: (ctx) => listTopicProjectOverlays(ctx, {
-      idMode: "legacy"
-    }),
-    getFinalArtifact: (ctx, artifactId) => ctx.db.get(artifactId)
-  };
+async function requireAuthenticatedUserId(ctx) {
+  const userId = await getCurrentUserId(
+    ctx
+  );
+  if (!userId) {
+    throwStructuredMutationError({
+      message: "Authentication required.",
+      status: 401,
+      code: "AUTHENTICATION_REQUIRED",
+      invariantCode: "auth.required",
+      suggestion: "Provide a valid bearer token before invoking belief mutations."
+    });
+  }
+  return userId;
 }
-var resolverOverrides = {};
-function resolveGraphPrimitivesAppResolvers(_ctx) {
-  return {
-    ...defaultResolvers(),
-    ...resolverOverrides
-  };
+async function requireProjectWriteAccess(ctx, projectId, userId) {
+  const hasAccess = await checkProjectAccess(
+    ctx,
+    projectId,
+    userId
+  );
+  if (!hasAccess) {
+    throwStructuredMutationError({
+      message: "Project access required.",
+      status: 403,
+      code: "FORBIDDEN",
+      invariantCode: "policy.scope_required",
+      suggestion: "Request write access for the project and retry.",
+      details: { projectId, userId }
+    });
+  }
 }
 
-// src/epistemicBeliefs.ts
-var insightIdUnion = v.id("epistemicNodes");
-var DEFAULT_PROJECT_BELIEF_LIMIT = 250;
-var MAX_PROJECT_BELIEF_LIMIT = 1e3;
-var optionalBeliefScopeArgs = optionalScopeArgs;
-var DEFAULT_CONFIDENCE_POLICY = {
-  scoringMode: "after_worktree",
-  tupleContradiction: normalizeTupleContradictionPolicy()
-};
-function throwStructuredMutationError(args) {
-  const error = new Error(args.message);
-  error.status = args.status;
-  error.code = args.code;
-  error.invariantCode = args.invariantCode;
-  error.suggestion = args.suggestion;
-  error.details = args.details;
-  throw error;
-}
-function readFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function clamp01(value) {
-  return Math.max(0, Math.min(1, value));
+// src/edges/contains.ts
+var containsPropagationSpec = {
+  edgeType: "contains",
+  direction: "outgoing",
+  transitivity: "none",
+  damping: 1,
+  maxHops: 1,
+  operator: () => null,
+  description: "Structural containment only. Traversed for explicit semantics, but it never propagates opinions."
+};
+function readEdgeMetadata(edge) {
+  return {
+    constraint: edge.constraint ?? void 0,
+    normalization: edge.normalization ?? void 0,
+    propagation: edge.propagation ?? void 0,
+    conditionalA: edge.conditionalA ?? void 0,
+    conditionalNotA: edge.conditionalNotA ?? void 0
+  };
 }
-function assertBaseRateInRange(baseRate, field = "baseRate") {
-  if (baseRate < 0 || baseRate > 1) {
-    throwStructuredMutationError({
-      message: `${field} must be within [0, 1].`,
-      status: 400,
-      code: "INVALID_ARGUMENT",
-      invariantCode: "request.valid_shape",
-      suggestion: `Clamp ${field} into the inclusive [0, 1] interval.`,
-      details: { field, baseRate }
-    });
+function applyPerHopDamping(sourceOpinion, damping) {
+  if (damping >= 1) {
+    return sourceOpinion;
   }
-  return baseRate;
+  return trustDiscount(sourceOpinion, Math.max(0, damping));
 }
-function buildBeliefConfidenceRow(args) {
+function annotateRationale(result, spec, hop) {
   return {
-    beliefId: args.beliefId,
-    confidence: confidenceFromSL(
-      args.belief,
-      args.disbelief,
-      args.uncertainty,
-      args.baseRate
-    ),
-    belief: args.belief,
-    disbelief: args.disbelief,
-    uncertainty: args.uncertainty,
-    baseRate: args.baseRate,
-    slOperator: args.slOperator ?? "manual_assessment",
-    trigger: args.trigger,
-    ...args.rationale ? { rationale: args.rationale } : {},
-    assessedBy: args.assessedBy,
-    assessedAt: args.assessedAt,
-    ...args.triggeringEvidenceId ? {
-      triggeringEvidenceId: args.triggeringEvidenceId,
-      triggeringEvidenceIds: [String(args.triggeringEvidenceId)]
-    } : {},
-    ...args.triggeringContradictionId ? {
-      triggeringContradictionId: args.triggeringContradictionId
-    } : {},
-    ...args.triggeringWorktreeId ? { triggeringWorktreeId: args.triggeringWorktreeId } : {}
+    ...result,
+    rationale: `hop=${hop} edge=${spec.edgeType} damping=${spec.damping.toFixed(
+      2
+    )} :: ${result.rationale}`
   };
 }
-function buildBeliefStatusSuccessResult() {
-  return { success: true };
-}
-function buildBeliefEvidenceNotFoundResult() {
-  const result = {};
-  result.success = false;
-  result.message = "Evidence node not found";
-  return result;
+function propagatePositiveSupport(sourceOpinion, targetOpinion, edgeWeight) {
+  const discounted = trustDiscount(sourceOpinion, Math.abs(edgeWeight));
+  return {
+    opinion: cumulativeFusion(targetOpinion, discounted),
+    operator: "cumulative_fusion",
+    rationale: `Supporting evidence (weight=${edgeWeight.toFixed(
+      2
+    )}) from source at ${project(sourceOpinion).toFixed(2)}`
+  };
 }
-function deriveSyntheticBackfillOpinion(source) {
-  const belief = readFiniteNumber(source.opinion_b) ?? readFiniteNumber(source.belief);
-  const disbelief = readFiniteNumber(source.opinion_d) ?? readFiniteNumber(source.disbelief);
-  const uncertainty = readFiniteNumber(source.opinion_u) ?? readFiniteNumber(source.uncertainty);
-  const baseRate = readFiniteNumber(source.opinion_a) ?? readFiniteNumber(source.baseRate);
-  if (belief !== void 0 || disbelief !== void 0 || uncertainty !== void 0 || baseRate !== void 0) {
-    try {
-      return readOpinionFromRecord(source);
-    } catch (error) {
-      debugGraphPrimitiveFallback(
-        "[epistemicBeliefs] Failed to decode legacy belief opinion",
-        {
-          error
-        }
-      );
-      return mkOpinion(0, 0, 1, 0.5);
-    }
-  }
-  const confidence = clamp01(readFiniteNumber(source.confidence) ?? 0);
-  return mkOpinion(confidence, 1 - confidence, 0, 0.5);
+function propagatePositiveInform(sourceOpinion, targetOpinion, edgeWeight) {
+  const discounted = trustDiscount(sourceOpinion, Math.abs(edgeWeight));
+  return {
+    opinion: cumulativeFusion(targetOpinion, discounted),
+    operator: "cumulative_fusion",
+    rationale: `Supporting evidence (weight=${edgeWeight.toFixed(2)})`
+  };
 }
-function clampBeliefLimit(limit, fallback = DEFAULT_PROJECT_BELIEF_LIMIT) {
-  if (!Number.isFinite(limit)) {
-    return fallback;
-  }
-  return Math.max(
-    1,
-    Math.min(Math.floor(limit), MAX_PROJECT_BELIEF_LIMIT)
+function propagateNegativeSupportWithMetadata(sourceOpinion, targetOpinion, edgeWeight, edge) {
+  return applyNegativeSupport(
+    sourceOpinion,
+    targetOpinion,
+    edgeWeight,
+    readEdgeMetadata(edge)
   );
 }
-function readTupleContradictedFlag(value) {
-  return typeof value === "boolean" ? value : void 0;
-}
-function readBeliefOpinionSnapshot(node, metadata) {
-  try {
-    return readOpinionFromRecord({
-      ...metadata,
-      opinion_b: node.opinion_b,
-      opinion_d: node.opinion_d,
-      opinion_u: node.opinion_u,
-      opinion_a: node.opinion_a
-    });
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[epistemicBeliefs] Failed to read belief opinion snapshot",
-      {
-        error,
-        beliefId: node._id
-      }
+var propagateNegativeInform = applyNegativeEvidence;
+
+// src/edges/contradicts.ts
+var contradictsPropagationSpec = {
+  edgeType: "contradicts",
+  direction: "bidirectional",
+  transitivity: "none",
+  damping: 0.85,
+  maxHops: 1,
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
     );
-    return mkOpinion(0, 0, 1, 0.5);
-  }
-}
-function deriveTupleContradictionSeverity(node) {
-  const metadata = node.metadata || {};
-  const criticality = typeof metadata.criticality === "string" ? metadata.criticality : void 0;
-  if (criticality === "blocking") {
-    return "critical";
-  }
-  if (criticality === "supporting") {
-    return "minor";
-  }
-  return "significant";
-}
-function formatTupleContradictionDescription(args) {
-  return `Tuple-space contradiction detected: b=${args.opinion.b.toFixed(2)} > ${args.policy.beliefThreshold.toFixed(2)} and d=${args.opinion.d.toFixed(2)} > ${args.policy.disbeliefThreshold.toFixed(2)}.`;
-}
-function generateContentHash(text) {
-  const content = `belief:${text.trim().toLowerCase().replace(/\s+/g, " ")}`;
-  let hash = 5381;
-  for (let i = 0; i < content.length; i++) {
-    hash = (hash << 5) + hash + content.charCodeAt(i);
-    hash &= hash;
-  }
-  return Math.abs(hash).toString(16).padStart(8, "0");
-}
-function resolveBeliefWorktreeId(metadata) {
-  const worktreeId = metadata?.worktreeId;
-  if (typeof worktreeId === "string" && worktreeId.trim().length > 0) {
-    return worktreeId;
-  }
-  const sprintId = metadata?.sprintId;
-  return typeof sprintId === "string" && sprintId.trim().length > 0 ? sprintId : void 0;
-}
-function normalizePillar(pillar) {
-  if (!pillar) {
-    return "other";
-  }
-  const lower = pillar.toLowerCase();
-  const validPillars = [
-    "market",
-    "competition",
-    "product",
-    "team",
-    "financials",
-    "regulatory",
-    "timing",
-    "customer",
-    "technology",
-    "distribution",
-    "deal",
-    "risks"
-  ];
-  return validPillars.find((p) => lower.includes(p)) || "other";
-}
-async function markBeliefGraphDirty(ctx, scope) {
-  const projectId = typeof scope.projectId === "string" && scope.projectId.trim().length > 0 ? scope.projectId : void 0;
-  const topicId = typeof scope.topicId === "string" && scope.topicId.trim().length > 0 ? scope.topicId : void 0;
-  if (!projectId && !topicId) {
-    return;
-  }
-  if (projectId) {
-    await ctx.scheduler.runAfter(
-      0,
-      internal.graphAnalysisCache.markCacheStaleInternal,
-      { projectId }
+    const negativeWeight = -Math.abs(edge.weight ?? 1);
+    const result = propagateNegativeSupportWithMetadata(
+      dampedSource,
+      targetOpinion,
+      negativeWeight,
+      edge
     );
-  }
-  if (topicId) {
-    await ctx.scheduler.runAfter(
-      0,
-      internal.graphAnalysisCache.markCacheStaleByTopic,
-      { topicId }
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Legacy contradiction edges move negative pressure in either direction, but never beyond one hop."
+};
+var dependsOnPropagationSpec = {
+  edgeType: "depends_on",
+  direction: "incoming",
+  transitivity: "damped",
+  damping: 0.8,
+  maxHops: "unbounded",
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
     );
-  }
-  await resolveGraphPrimitivesAppResolvers().patchProject(
-    ctx,
-    topicId ?? projectId,
-    {
-      lastActivityAt: Date.now()
+    const metadata = readEdgeMetadata(edge);
+    if (metadata.conditionalA && metadata.conditionalNotA) {
+      const deducedOpinion = conditionalDeduction(
+        dampedSource,
+        mkOpinion(
+          metadata.conditionalA.b,
+          metadata.conditionalA.d,
+          metadata.conditionalA.u,
+          metadata.conditionalA.a
+        ),
+        mkOpinion(
+          metadata.conditionalNotA.b,
+          metadata.conditionalNotA.d,
+          metadata.conditionalNotA.u,
+          metadata.conditionalNotA.a
+        ),
+        targetOpinion.a
+      );
+      return annotateRationale(
+        {
+          opinion: deducedOpinion,
+          operator: "conditional_deduction",
+          rationale: `Conditional deduction: prerequisite at ${project(
+            dampedSource
+          ).toFixed(2)}`
+        },
+        context.spec,
+        context.hop
+      );
     }
-  );
-}
-async function resolveBeliefScopeOrNull(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 (error) {
-    debugGraphPrimitiveFallback(
-      "[epistemicBeliefs] Failed to resolve belief scope",
-      {
-        error,
-        projectId: args.projectId,
-        topicId: args.topicId
-      }
+    const result = dampedDependencyCascade(
+      dampedSource,
+      targetOpinion,
+      metadata.propagation ?? "continuous"
     );
-    return null;
-  }
-}
-async function getBeliefNodesForScope(ctx, scope, args) {
-  const baseQuery = ctx.db.query("epistemicNodes").withIndex(
-    "by_topic_type",
-    (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
-  );
-  const nodes = typeof args?.scanLimit === "number" ? await baseQuery.order("desc").take(args.scanLimit) : await baseQuery.collect();
-  const scopedNodes = nodes.filter(
-    (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
-  );
-  if (!args?.status) {
-    return scopedNodes;
-  }
-  return scopedNodes.filter((node) => node.status === args.status);
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Structural gating. Textbook conditional deduction when edge conditionals exist, otherwise damped dependency cascade through downstream chains."
+};
+
+// src/edges/derivedFrom.ts
+var derivedFromPropagationSpec = {
+  edgeType: "derived_from",
+  direction: "incoming",
+  transitivity: "none",
+  damping: 1,
+  maxHops: 1,
+  operator: () => null,
+  description: "Provenance only. The traversal surface stays explicit, but confidence does not move across derived_from edges."
+};
+
+// src/edges/elaborates.ts
+var elaboratesPropagationSpec = {
+  edgeType: "elaborates",
+  direction: "outgoing",
+  transitivity: "damped",
+  damping: 0.7,
+  maxHops: 2,
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const contextualWeight = Math.min(Math.abs(edge.weight ?? 0.35), 0.35);
+    const result = propagatePositiveInform(
+      dampedSource,
+      targetOpinion,
+      contextualWeight
+    );
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Context-rich supporting detail. Elaborates carries a small positive effect with short, damped chaining."
+};
+
+// src/edges/informs.ts
+var informsPropagationSpec = {
+  edgeType: "informs",
+  direction: "outgoing",
+  transitivity: "full",
+  damping: 0.92,
+  maxHops: "unbounded",
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const weight = edge.weight ?? 1;
+    const result = weight < 0 ? propagateNegativeInform(dampedSource, targetOpinion, weight) : propagatePositiveInform(dampedSource, targetOpinion, weight);
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Evidence-bearing influence. Informs can chain through the graph with light per-hop damping."
+};
+
+// src/edges/propagationTypes.ts
+function isPropagationTraversalDirection(direction) {
+  return direction === "outgoing" || direction === "incoming";
 }
-function createBeliefAudienceResolver(registryRows) {
-  const audienceClassByKey = new Map(
-    registryRows.map((row) => [
-      normalizeAudienceKey(row.audienceKey),
-      row.audienceClass
-    ])
-  );
-  return (audienceKey, fallback) => {
-    const key = normalizeAudienceKey(audienceKey);
-    if (!key) {
-      return fallback;
-    }
-    return audienceClassByKey.get(key) ?? classFromAudienceKey(key, fallback);
-  };
+function canTraverseHop(spec, nextHop) {
+  return spec.maxHops === "unbounded" || nextHop <= spec.maxHops;
 }
-function flattenBeliefNode(node) {
-  const meta = node.metadata || {};
-  const worktreeId = resolveBeliefWorktreeId(meta);
-  const tupleContradicted = readTupleContradictedFlag(node.tupleContradicted) ?? readTupleContradictedFlag(meta.tupleContradicted) ?? false;
-  return {
-    _id: node._id,
-    _epistemicNodeId: node._id,
-    _creationTime: node._creationTime,
-    belief: node.canonicalText,
-    formulation: node.canonicalText,
-    projectId: node.projectId,
-    topicId: node.topicId,
-    userId: node.userId || node.createdBy || "",
-    confidence: meta.confidence || "untested",
-    status: node.status,
-    beliefStatus: resolveBeliefStatus(node, meta),
-    topic: meta.topic || meta.pillar || "other",
-    pillar: meta.pillar || meta.topic || "",
-    category: meta.category || "",
-    subcategory: meta.subcategory || "",
-    categoryIcon: meta.categoryIcon || "",
-    supportingEvidence: meta.supportingEvidenceIds || [],
-    contradictingEvidence: meta.contradictingEvidenceIds || [],
-    testingQuestions: meta.testingQuestionIds || [],
-    linkedInsights: meta.linkedInsightIds || [],
-    createdAt: node.createdAt,
-    updatedAt: node.updatedAt || node.createdAt,
-    tupleContradicted,
-    sprintId: meta.sprintId || void 0,
-    worktreeId,
-    sourceBeliefIds: meta.sourceBeliefIds || void 0,
-    criticality: meta.criticality || "unanalyzed",
-    rationale: meta.rationale || "",
-    audienceLabel: node.audienceLabel,
-    policyTags: node.policyTags,
-    sensitivityTier: node.sensitivityTier,
-    exportClass: node.exportClass,
-    anonymizationClass: node.anonymizationClass
-  };
+function canContinueTransitively(spec, currentHop) {
+  if (spec.transitivity === "none") {
+    return false;
+  }
+  return spec.maxHops === "unbounded" || currentHop < spec.maxHops;
 }
-function resolveBeliefStatus(node, metadata) {
-  return resolveBeliefLifecycleStatus({
-    beliefStatus: node.beliefStatus,
-    confidence: node.confidence,
-    predictionMeta: node.predictionMeta,
-    metadata
-  });
+
+// src/edges/refutes.ts
+var refutesPropagationSpec = {
+  edgeType: "refutes",
+  direction: "outgoing",
+  transitivity: "none",
+  damping: 0.9,
+  maxHops: 1,
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const negativeWeight = -Math.abs(edge.weight ?? 1);
+    const result = propagateNegativeInform(
+      dampedSource,
+      targetOpinion,
+      negativeWeight
+    );
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Explicit negative evidence semantics. Refutes is treated as strong one-hop counter-evidence."
+};
+
+// src/edges/supports.ts
+var supportsPropagationSpec = {
+  edgeType: "supports",
+  direction: "outgoing",
+  transitivity: "full",
+  damping: 0.85,
+  maxHops: "unbounded",
+  operator: (sourceOpinion, targetOpinion, edge, context) => {
+    const dampedSource = applyPerHopDamping(
+      sourceOpinion,
+      context.spec.damping
+    );
+    const weight = edge.weight ?? 1;
+    const result = weight < 0 ? propagateNegativeSupportWithMetadata(
+      dampedSource,
+      targetOpinion,
+      weight,
+      edge
+    ) : propagatePositiveSupport(dampedSource, targetOpinion, weight);
+    return annotateRationale(result, context.spec, context.hop);
+  },
+  description: "Belief-to-belief influence. Supports chains transitively with moderate per-hop damping."
+};
+
+// src/edges/tests.ts
+var testsPropagationSpec = {
+  edgeType: "tests",
+  direction: "outgoing",
+  transitivity: "none",
+  damping: 1,
+  maxHops: 1,
+  operator: () => null,
+  description: "Interrogation linkage only. Tests edges do not directly move confidence."
+};
+
+// src/edges/index.ts
+var EDGE_PROPAGATION_SPECS = [
+  supportsPropagationSpec,
+  informsPropagationSpec,
+  dependsOnPropagationSpec,
+  derivedFromPropagationSpec,
+  containsPropagationSpec,
+  testsPropagationSpec,
+  contradictsPropagationSpec,
+  refutesPropagationSpec,
+  elaboratesPropagationSpec
+];
+new Map(EDGE_PROPAGATION_SPECS.map((spec) => [spec.edgeType, spec]));
+function getEdgePropagationSpecs() {
+  return EDGE_PROPAGATION_SPECS;
 }
-async function hasCompletedWorktreeForBelief(ctx, beliefNodeId) {
-  const clusterMembership = await ctx.db.query("worktreeBeliefCluster").withIndex("by_belief", (q) => q.eq("beliefId", beliefNodeId)).collect();
-  for (const membership of clusterMembership) {
-    const worktree = await ctx.db.get(membership.worktreeId);
-    if (worktree?.status === "completed" || worktree?.status === "merged") {
-      return true;
-    }
+function getTraversalDirections(direction) {
+  if (isPropagationTraversalDirection(direction)) {
+    return [direction];
   }
-  return false;
+  return ["outgoing", "incoming"];
+}
+
+// src/confidencePropagationDispatch.ts
+function resolveTraversalTargetNodeId(edge, direction) {
+  const targetNodeId = direction === "outgoing" ? edge.toNodeId : edge.fromNodeId;
+  return targetNodeId ?? void 0;
 }
-async function getActiveConfidencePolicy(ctx) {
+function readNodeOpinion(node) {
+  const metadata = node.metadata ?? {};
   try {
-    const activeConfig = await ctx.db.query("logicSprintScoring").withIndex("by_active", (q) => q.eq("isActive", true)).first();
-    return {
-      scoringMode: activeConfig?.confidencePolicy === "always" ? "always" : DEFAULT_CONFIDENCE_POLICY.scoringMode,
-      tupleContradiction: normalizeTupleContradictionPolicy(
-        activeConfig?.tupleContradictionPolicy
-      )
-    };
-  } catch (error) {
-    debugGraphPrimitiveFallback(
-      "[epistemicBeliefs] Failed to load active confidence policy",
-      {
-        error
+    return readOpinionFromRecord({
+      ...metadata,
+      opinion_b: node.opinion_b,
+      opinion_d: node.opinion_d,
+      opinion_u: node.opinion_u,
+      opinion_a: node.opinion_a
+    });
+  } catch {
+    return mkOpinion(0, 0, 1, 0.5);
+  }
+}
+async function collectConfidencePropagationDispatches(args) {
+  const dispatchesByTargetId = /* @__PURE__ */ new Map();
+  const opinionCache = /* @__PURE__ */ new Map();
+  const nodeCache = /* @__PURE__ */ new Map();
+  const traversalSpecs = args.traversalSpecs ?? getEdgePropagationSpecs();
+  const queue = [
+    {
+      nodeId: args.sourceNodeId,
+      opinion: args.sourceOpinion,
+      hop: 0,
+      visitedNodeIds: /* @__PURE__ */ new Set([String(args.sourceNodeId)])
+    }
+  ];
+  const loadNode = async (nodeId) => {
+    const cacheKey = String(nodeId);
+    if (!nodeCache.has(cacheKey)) {
+      nodeCache.set(cacheKey, await args.getNode(nodeId));
+    }
+    return nodeCache.get(cacheKey) ?? null;
+  };
+  while (queue.length > 0) {
+    const state = queue.shift();
+    if (!state) {
+      continue;
+    }
+    for (const spec of traversalSpecs) {
+      const nextHop = state.hop + 1;
+      if (!canTraverseHop(spec, nextHop)) {
+        continue;
       }
-    );
-    return DEFAULT_CONFIDENCE_POLICY;
+      for (const direction of getTraversalDirections(spec.direction)) {
+        const edges = await args.queryEdges({
+          nodeId: state.nodeId,
+          spec,
+          direction,
+          hop: nextHop
+        });
+        for (const edge of edges) {
+          if (args.sourceScope && !edgeMatchesWorkspaceReasoningScope(edge, args.sourceScope)) {
+            continue;
+          }
+          const targetNodeId = resolveTraversalTargetNodeId(edge, direction);
+          if (!targetNodeId) {
+            continue;
+          }
+          if (state.visitedNodeIds.has(String(targetNodeId))) {
+            continue;
+          }
+          const targetNode = await loadNode(targetNodeId);
+          if (!targetNode || targetNode.nodeType !== "belief") {
+            continue;
+          }
+          if (args.sourceScope && !nodeMatchesWorkspaceReasoningScope(targetNode, args.sourceScope)) {
+            continue;
+          }
+          const cacheKey = String(targetNodeId);
+          const targetOpinion = opinionCache.get(cacheKey) ?? readNodeOpinion(targetNode);
+          const result = spec.operator(state.opinion, targetOpinion, edge, {
+            hop: nextHop,
+            sourceNodeId: state.nodeId,
+            targetNodeId,
+            traversedDirection: direction,
+            spec
+          });
+          if (!result || !hasProjectedOpinionChanged(targetOpinion, result.opinion)) {
+            continue;
+          }
+          const projectedOpinion = mkOpinion(
+            result.opinion.b,
+            result.opinion.d,
+            result.opinion.u,
+            result.opinion.a
+          );
+          opinionCache.set(cacheKey, projectedOpinion);
+          const existingDispatch = dispatchesByTargetId.get(cacheKey);
+          dispatchesByTargetId.set(cacheKey, {
+            targetNodeId,
+            edgeType: spec.edgeType,
+            traversedDirection: direction,
+            weight: edge.weight ?? 1,
+            opinion: projectedOpinion,
+            operator: result.operator,
+            rationale: existingDispatch ? `${existingDispatch.rationale}; ${result.rationale}` : result.rationale,
+            hop: nextHop
+          });
+          if (canContinueTransitively(spec, nextHop)) {
+            queue.push({
+              nodeId: targetNodeId,
+              opinion: projectedOpinion,
+              hop: nextHop,
+              visitedNodeIds: /* @__PURE__ */ new Set([
+                ...state.visitedNodeIds,
+                String(targetNodeId)
+              ])
+            });
+          }
+        }
+      }
+    }
   }
+  return Array.from(dispatchesByTargetId.values()).sort((left, right) => {
+    if (left.hop !== right.hop) {
+      return left.hop - right.hop;
+    }
+    return String(left.targetNodeId).localeCompare(String(right.targetNodeId));
+  });
 }
+
+// src/epistemicBeliefs.confidence.ts
 async function applyBeliefConfidenceChange(ctx, args) {
   const now = Date.now();
   const node = await ctx.db.get(args.nodeId);
@@ -1976,32 +1906,49 @@ var propagateConfidenceChange = internalMutation({
     };
   }
 });
-async function requireAuthenticatedUserId(ctx) {
-  const userId = await getCurrentUserId(ctx);
-  if (!userId) {
-    throwStructuredMutationError({
-      message: "Authentication required.",
-      status: 401,
-      code: "AUTHENTICATION_REQUIRED",
-      invariantCode: "auth.required",
-      suggestion: "Provide a valid bearer token before invoking belief mutations."
-    });
+
+// 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
+      }
+    );
   }
-  return userId;
 }
-async function requireProjectWriteAccess(ctx, projectId, userId) {
-  const hasAccess = await checkProjectAccess(ctx, projectId, userId);
-  if (!hasAccess) {
-    throwStructuredMutationError({
-      message: "Project access required.",
-      status: 403,
-      code: "FORBIDDEN",
-      invariantCode: "policy.scope_required",
-      suggestion: "Request write access for the project and retry.",
-      details: { projectId, userId }
-    });
-  }
+
+// 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/epistemicBeliefs.core.ts
 var create = mutation({
   args: {
     ...optionalBeliefScopeArgs,
@@ -2419,11 +2366,11 @@ var getByProject = query({
         return [];
       }
     }
-    const query2 = ctx.db.query("epistemicNodes").withIndex(
+    const query6 = ctx.db.query("epistemicNodes").withIndex(
       "by_topic_type",
       (q) => q.eq("topicId", scope.topicId).eq("nodeType", "belief")
     );
-    const nodes = await query2.order("desc").take(scanLimit);
+    const nodes = await query6.order("desc").take(scanLimit);
     const scopedNodes = nodes.filter(
       (node) => nodeMatchesWorkspaceReasoningScope(node, scope)
     );
@@ -2453,11 +2400,11 @@ var getByTopic = query({
     const scope = await resolveTopicProjectScope(ctx, {
       topicId: args.topicId
     });
-    const query2 = ctx.db.query("epistemicNodes").withIndex(
+    const query6 = ctx.db.query("epistemicNodes").withIndex(
       "by_topic_type",
       (q) => q.eq("topicId", args.topicId).eq("nodeType", "belief")
     );
-    const nodes = await query2.order("desc").take(scanLimit);
+    const nodes = await query6.order("desc").take(scanLimit);
     const scopedNodes = nodes.filter(
       (node) => nodeMatchesWorkspaceReasoningScope(node, {
         tenantId: scope.tenantId,
@@ -2962,7 +2909,9 @@ var getByIds = query({
   },
   returns: permissiveReturn,
   handler: async (ctx, args) => {
-    const beliefs = await Promise.all(args.nodeIds.map((id) => ctx.db.get(id)));
+    const beliefs = await Promise.all(
+      args.nodeIds.map((id) => ctx.db.get(id))
+    );
     return beliefs.filter((b) => b !== null && b.nodeType === "belief");
   }
 });
@@ -2985,6 +2934,69 @@ var getByWorktree = query({
     return beliefs;
   }
 });
+
+// src/logicalRoleInference.ts
+var PILLAR_IMPORTANCE = {
+  market: 1,
+  competition: 2,
+  product: 3,
+  team: 4,
+  financials: 5,
+  timing: 6,
+  other: 10
+};
+async function computeLogicalRole(ctx, evidenceId, beliefId) {
+  const belief = await ctx.db.get(beliefId);
+  if (!belief || belief.nodeType !== "belief") {
+    return "contributory";
+  }
+  const beliefMetadata = belief.metadata;
+  const pillar = beliefMetadata?.pillar || "other";
+  const pillarRank = PILLAR_IMPORTANCE[pillar] ?? 10;
+  const isSynthesized = await checkIfSynthesizedHypothesis(ctx, beliefId);
+  const testingQuestions = await getTestingQuestionsForBelief(ctx, beliefId);
+  const answeredQuestions = await getQuestionsAnsweredByEvidence(
+    ctx,
+    evidenceId
+  );
+  const directlyTests = testingQuestions.filter(
+    (questionId) => answeredQuestions.includes(questionId)
+  );
+  if (directlyTests.length === 0) {
+    return "contributory";
+  }
+  if (isSynthesized && pillarRank <= 2) {
+    return directlyTests.length > 1 ? "necessary_sufficient" : "necessary";
+  }
+  if (isSynthesized) {
+    return "necessary";
+  }
+  return directlyTests.length > 1 ? "necessary" : "contributory";
+}
+async function checkIfSynthesizedHypothesis(ctx, beliefId) {
+  const belief = await ctx.db.get(beliefId);
+  if (!belief) {
+    return false;
+  }
+  const metadata = belief.metadata;
+  return metadata?.isSynthesized === true || metadata?.beliefStatus === "hypothesis";
+}
+async function getTestingQuestionsForBelief(ctx, beliefId) {
+  const testEdges = await ctx.db.query("epistemicEdges").withIndex(
+    "by_to_type",
+    (q) => q.eq("toNodeId", beliefId).eq("edgeType", "tests")
+  ).collect();
+  return testEdges.map((edge) => edge.fromNodeId).filter((id) => id !== void 0);
+}
+async function getQuestionsAnsweredByEvidence(ctx, evidenceId) {
+  const answerEdges = await ctx.db.query("epistemicEdges").withIndex(
+    "by_from_type",
+    (q) => q.eq("fromNodeId", evidenceId).eq("edgeType", "derived_from")
+  ).collect();
+  return answerEdges.map((edge) => edge.toNodeId).filter((id) => id !== void 0);
+}
+
+// src/epistemicBeliefs.links.ts
 var updatePillar = mutation({
   args: {
     nodeId: v.id("epistemicNodes"),
@@ -3775,11 +3787,11 @@ var internalGetByTopic = internalQuery({
     });
     const resolveAudienceClass = createBeliefAudienceResolver(registryRows);
     const viewerClass = resolveAudienceClass(audienceMode, "public");
-    const query2 = ctx.db.query("epistemicNodes").withIndex(
+    const query6 = ctx.db.query("epistemicNodes").withIndex(
       "by_topic_type",
       (q) => q.eq("topicId", args.topicId).eq("nodeType", "belief")
     );
-    const nodes = await query2.order("desc").take(scanLimit);
+    const nodes = await query6.order("desc").take(scanLimit);
     let filtered = nodes.filter(
       (node) => canAudienceClassAccess(
         viewerClass,