@lucern/graph-primitives 0.1.0-alpha.2

package/dist/workspaceIsolation.js

@@ -0,0 +1,950 @@
+import { defineTable, componentsGeneric, anyApi } from 'convex/server';
+import { v } from 'convex/values';
+
+// ../schema-management/src/spine/tables/epistemicNodes.ts
+v.optional(v.any());
+var looseJsonObject = v.record(v.string(), v.any());
+var looseJsonArray = v.array(v.any());
+v.union(
+  v.string(),
+  v.number(),
+  v.boolean(),
+  v.null(),
+  looseJsonObject,
+  looseJsonArray
+);
+
+// ../schema-management/src/shared/common.ts
+v.number();
+v.union(
+  v.literal("very_high"),
+  // 0.9+
+  v.literal("high"),
+  // 0.7-0.9
+  v.literal("medium"),
+  // 0.4-0.7
+  v.literal("low"),
+  // 0.2-0.4
+  v.literal("very_low")
+  // 0-0.2
+);
+v.union(
+  v.literal(1),
+  // Critical
+  v.literal(2),
+  // High
+  v.literal(3),
+  // Medium
+  v.literal(4),
+  // Low
+  v.literal(5)
+  // Backlog
+);
+v.union(
+  v.literal("critical"),
+  v.literal("high"),
+  v.literal("medium"),
+  v.literal("low"),
+  v.literal("backlog")
+);
+v.union(
+  v.literal("active"),
+  v.literal("paused"),
+  v.literal("completed"),
+  v.literal("archived")
+);
+v.union(
+  v.literal("pending"),
+  v.literal("processing"),
+  v.literal("completed"),
+  v.literal("failed")
+);
+v.object({
+  crunchbaseId: v.optional(v.string()),
+  linkedinUrl: v.optional(v.string()),
+  pitchbookId: v.optional(v.string()),
+  twitterUrl: v.optional(v.string()),
+  domain: v.optional(v.string())
+});
+var sourceType = v.union(
+  v.literal("proprietary"),
+  // Internal Stack research
+  v.literal("primary"),
+  // Direct interviews, calls
+  v.literal("secondary"),
+  // Published sources
+  v.literal("ai_generated"),
+  // AI-synthesized
+  v.literal("user_input"),
+  // Manual user entry
+  v.literal("inferred")
+  // System inference
+);
+v.object({
+  sourceType: v.optional(sourceType),
+  sourceId: v.optional(v.string()),
+  // Reference to source entity
+  sourceUrl: v.optional(v.string()),
+  sourceDate: v.optional(v.number()),
+  sourceName: v.optional(v.string())
+});
+v.object({
+  cursor: v.optional(v.string()),
+  limit: v.optional(v.number())
+});
+v.object({
+  hasMore: v.boolean(),
+  nextCursor: v.optional(v.string()),
+  totalCount: v.optional(v.number())
+});
+var richTextContent = v.object({
+  type: v.literal("doc"),
+  content: looseJsonArray
+});
+v.union(v.string(), richTextContent);
+v.object({
+  promptTokens: v.optional(v.number()),
+  completionTokens: v.optional(v.number()),
+  totalTokens: v.optional(v.number())
+});
+v.object({
+  fileName: v.optional(v.string()),
+  fileSize: v.optional(v.number()),
+  mimeType: v.optional(v.string()),
+  storageId: v.optional(v.id("_storage")),
+  externalUrl: v.optional(v.string())
+});
+
+// ../schema-management/src/spine/tables/epistemicNodes.ts
+var nodeType = v.union(
+  // --- L4: Audit Targets (decisions, outcomes) ---
+  v.literal("decision"),
+  // Investment decision with knowledge horizon snapshot
+  // --- L3: Traversal Anchors (epistemic structure) ---
+  v.literal("belief"),
+  // Structured conviction (immutable formulation)
+  v.literal("question"),
+  // Unit of uncertainty
+  v.literal("theme"),
+  // Investment thesis / conviction cluster
+  v.literal("deal"),
+  // Investment evaluation process
+  v.literal("topic"),
+  // Hierarchical knowledge container
+  // --- L2: Compression Boundary (minimum reasoning unit) ---
+  v.literal("claim"),
+  // Atomic assertion that can be true/false
+  v.literal("evidence"),
+  // Interpreted signal linked to beliefs
+  v.literal("synthesis"),
+  // Primers, deep research
+  v.literal("answer"),
+  // Immutable answer snapshot for a question
+  // --- L1: Terminal Leaves (non-traversable, grounding) ---
+  v.literal("atomic_fact"),
+  // Raw fact from source (not interpreted)
+  v.literal("excerpt"),
+  // Direct quote from source document
+  v.literal("source"),
+  // News, documents, transcripts
+  // --- Ontological Entities (things in the world) ---
+  v.literal("company"),
+  // Organization (subtype: private, corporate, portfolio)
+  v.literal("person"),
+  // Individual (founder, expert, LP, contact)
+  v.literal("investor"),
+  // Investment entity (subtype: vc, lp, cvc, pe, family_office, angel)
+  v.literal("function"),
+  // What a company does (from classifier)
+  v.literal("value_chain")
+  // Market structure / value flow
+);
+var epistemicLayer = v.union(
+  v.literal("L4"),
+  // Decisions, outcomes - audit targets
+  v.literal("L3"),
+  // Beliefs, questions, themes - traversal anchors
+  v.literal("L2"),
+  // Claims, evidence, synthesis - compression boundary
+  v.literal("L1"),
+  // Atomic facts, excerpts, sources - terminal leaves
+  v.literal("ontological"),
+  // Companies, people, etc - not epistemic
+  v.literal("organizational")
+  // Topics, lenses, worktrees — structural containers
+);
+var nodeStatus = v.union(
+  v.literal("active"),
+  v.literal("superseded"),
+  // Replaced by newer version
+  v.literal("archived"),
+  v.literal("deleted")
+);
+var sourceType2 = v.union(
+  v.literal("human"),
+  // User created directly
+  v.literal("ai_extracted"),
+  // LLM extracted from a source
+  v.literal("ai_generated"),
+  // LLM synthesized/created
+  v.literal("imported"),
+  // External system import
+  v.literal("system"),
+  // System-generated (migrations, classifiers)
+  v.literal("verified"),
+  // Human-verified source
+  v.literal("proprietary")
+  // Proprietary/internal data
+);
+var verificationStatus = v.union(
+  v.literal("unverified"),
+  v.literal("human_verified"),
+  v.literal("ai_verified"),
+  v.literal("contradicted"),
+  v.literal("outdated")
+);
+var syncStatus = v.union(
+  v.literal("synced"),
+  // Node and edges fully synced to Neo4j
+  v.literal("pending_edges"),
+  // Node created, edges being created
+  v.literal("edge_creation_failed")
+  // Edge creation failed, needs retry
+);
+var audienceLabel = v.string();
+var sensitivityTier = v.union(
+  v.literal("low"),
+  v.literal("medium"),
+  v.literal("high"),
+  v.literal("restricted")
+);
+var exportClass = v.union(
+  v.literal("internal_only"),
+  v.literal("client_safe"),
+  v.literal("public_safe"),
+  v.literal("restricted")
+);
+var anonymizationClass = v.union(
+  v.literal("none"),
+  v.literal("standard"),
+  v.literal("strict")
+);
+var epistemicStatus = v.union(
+  v.literal("hypothesis"),
+  // Initial conjecture, low evidence
+  v.literal("emerging"),
+  // Building evidence, gaining traction
+  v.literal("established"),
+  // Well-evidenced, core to thesis
+  v.literal("challenged"),
+  // Contradicting evidence appeared
+  v.literal("assumption"),
+  // Taken as given, not actively tested
+  v.literal("deprecated")
+  // Superseded or abandoned
+);
+var beliefStatus = v.union(
+  v.literal("assumption"),
+  v.literal("hypothesis"),
+  v.literal("belief"),
+  v.literal("fact")
+);
+var reversibility = v.union(
+  v.literal("irreversible"),
+  // One-way door decision
+  v.literal("hard_to_reverse"),
+  // Significant cost to undo
+  v.literal("reversible"),
+  // Can change course with moderate effort
+  v.literal("trivial")
+  // Easy to adjust
+);
+var predictionOutcome = v.union(
+  v.literal("pending"),
+  v.literal("confirmed"),
+  v.literal("disconfirmed"),
+  v.literal("partial"),
+  v.literal("expired")
+);
+var predictionMeta = v.object({
+  isPrediction: v.boolean(),
+  registeredAt: v.number(),
+  // When prediction was made
+  expectedBy: v.optional(v.number()),
+  // When we expect resolution
+  outcome: v.optional(predictionOutcome),
+  outcomeRecordedAt: v.optional(v.number()),
+  outcomeEvidenceId: v.optional(v.string()),
+  // globalId of confirming evidence
+  confidenceAtPrediction: v.optional(v.number()),
+  // 0-1
+  actualVsPredicted: v.optional(v.string())
+  // Notes on how outcome compared
+});
+var methodology = v.union(
+  // Primary Research (high value)
+  v.literal("primary_research"),
+  // Direct investigation
+  v.literal("expert_interview"),
+  // Expert call/interview
+  v.literal("customer_interview"),
+  // Customer research
+  v.literal("field_observation"),
+  // On-site observation
+  v.literal("proprietary_data"),
+  // Internal data analysis
+  // Secondary Research
+  v.literal("desk_research"),
+  // Public sources
+  v.literal("regulatory_filing"),
+  // SEC, regulatory docs
+  v.literal("news_article"),
+  // News/press
+  v.literal("academic_paper"),
+  // Academic research
+  // AI-Assisted
+  v.literal("ai_synthesis"),
+  // AI-generated synthesis
+  v.literal("ai_extraction")
+  // AI-extracted from source
+);
+var informationAsymmetry = v.union(
+  v.literal("proprietary"),
+  // Only we have this
+  v.literal("early"),
+  // We're early but others will get it
+  v.literal("common")
+  // Everyone has access
+);
+var temporalNature = v.union(
+  v.literal("factual"),
+  // Resolved outcome. Grounded in reality.
+  v.literal("forecast"),
+  // Prediction. Will resolve. Discounted weight.
+  v.literal("unknown")
+  // Not yet classified.
+);
+var questionType = v.union(
+  v.literal("validation"),
+  // Does evidence support this belief?
+  v.literal("falsification"),
+  // What would prove this belief wrong?
+  v.literal("assumption_probe"),
+  // Is this unstated assumption true?
+  v.literal("prediction_test"),
+  // Will this predicted outcome occur?
+  v.literal("counterfactual"),
+  // What would we expect if X were false?
+  v.literal("discovery"),
+  // What don't we know yet?
+  v.literal("clarification"),
+  // What does X actually mean?
+  v.literal("comparison"),
+  // How does X compare to Y?
+  v.literal("causal"),
+  // What caused X?
+  v.literal("mechanism"),
+  // How does X work?
+  v.literal("general")
+  // Unclassified
+);
+var questionPriority = v.union(
+  v.literal("critical"),
+  // Blocks decision-making
+  v.literal("high"),
+  // Important for thesis
+  v.literal("medium"),
+  // Would be nice to know
+  v.literal("low")
+  // Background/curiosity
+);
+var answerQuality = v.union(
+  v.literal("definitive"),
+  // Clear, well-supported
+  v.literal("strong"),
+  // Good evidence, high confidence
+  v.literal("moderate"),
+  // Some evidence
+  v.literal("weak"),
+  // Limited evidence
+  v.literal("speculative"),
+  // Mostly conjecture
+  v.literal("unanswered")
+  // No answer yet
+);
+var consensusView = v.union(
+  v.literal("aligned"),
+  // We agree with market consensus
+  v.literal("ahead_of"),
+  // We see this before consensus does
+  v.literal("contrarian"),
+  // We actively disagree with consensus
+  v.literal("orthogonal"),
+  // We're looking at something consensus isn't discussing
+  v.literal("unknown")
+  // We don't know what consensus thinks
+);
+var themeConviction = v.union(
+  v.literal("high"),
+  // Strong conviction, actively deploying
+  v.literal("medium"),
+  // Building conviction
+  v.literal("low"),
+  // Exploring, not convicted
+  v.literal("negative")
+  // Actively avoiding
+);
+var decisionType = v.union(
+  v.literal("invest"),
+  v.literal("pass"),
+  v.literal("follow_on"),
+  v.literal("exit"),
+  v.literal("deep_dive"),
+  v.literal("monitor"),
+  v.literal("deprioritize"),
+  v.literal("thesis_adopt"),
+  v.literal("thesis_revise"),
+  v.literal("thesis_abandon")
+);
+var decisionOutcome = v.union(
+  v.literal("pending"),
+  v.literal("successful"),
+  v.literal("unsuccessful"),
+  v.literal("mixed"),
+  v.literal("unknown")
+);
+var externalIds2 = v.object({
+  crunchbase: v.optional(v.string()),
+  linkedin: v.optional(v.string()),
+  pitchbook: v.optional(v.string()),
+  twitter: v.optional(v.string()),
+  website: v.optional(v.string())
+});
+defineTable({
+  // === IDENTITY ===
+  globalId: v.string(),
+  // UUID - survives migration to Neo4j
+  // === TYPE ===
+  nodeType,
+  // === EPISTEMIC LAYER ===
+  epistemicLayer: v.optional(epistemicLayer),
+  // === SUBTYPE (for typed entities) ===
+  subtype: v.optional(v.string()),
+  // company: private|corporate|portfolio, investor: vc|lp|cvc|pe|family_office|angel
+  // === CONTENT ===
+  canonicalText: v.string(),
+  // The core content (belief statement, company name, etc.)
+  contentHash: v.string(),
+  // SHA256(nodeType + canonicalText) for deduplication
+  // Extended content (for sources/syntheses)
+  content: v.optional(v.string()),
+  // Full text for documents/articles
+  contentType: v.optional(v.string()),
+  // "markdown", "html", "pdf", "text"
+  // === METADATA ===
+  title: v.optional(v.string()),
+  // Display title
+  tags: v.optional(v.array(v.string())),
+  domain: v.optional(v.string()),
+  // For companies: website domain
+  // Type-specific metadata (flexible object - LEGACY)
+  // New code should use the typed fields below when available
+  metadata: v.optional(looseJsonObject),
+  // === POLICY / ENTITLEMENT ===
+  tenantId: v.optional(v.string()),
+  workspaceId: v.optional(v.string()),
+  ownerPrincipalId: v.optional(v.string()),
+  audienceLabel: v.optional(audienceLabel),
+  policyTags: v.optional(v.array(v.string())),
+  sensitivityTier: v.optional(sensitivityTier),
+  exportClass: v.optional(exportClass),
+  anonymizationClass: v.optional(anonymizationClass),
+  // === PUBLICATION (visibility-based, not copy-based) ===
+  // Publication expands who can see a workspace-local node — the node stays
+  // in its workspace, like a microservice exposing part of its API surface.
+  // Rules-based: pack/tenant-level publicationRules auto-evaluate on
+  // confidence changes and node creation. No manual click-by-click.
+  publicationStatus: v.optional(
+    v.union(
+      v.literal("unpublished"),
+      // Default: workspace-local only
+      v.literal("published"),
+      // Visible at tenant scope (rules matched)
+      v.literal("suppressed")
+      // Manually blocked even if rules match
+    )
+  ),
+  publishedAt: v.optional(v.number()),
+  // When publication status last changed to published
+  publishedBy: v.optional(v.string()),
+  // userId or "system:publication_rules" for auto-publish
+  // === TYPED METADATA FIELDS ===
+  // --- Belief ---
+  // Belief type — validated against schemaEnumConfig category "belief_type"
+  // Platform core: hypothesis, belief, principle, invariant, assumption,
+  //                tenet, prior, preference, goal, forecast
+  beliefType: v.optional(v.string()),
+  beliefStatus: v.optional(beliefStatus),
+  epistemicStatus: v.optional(epistemicStatus),
+  reversibility: v.optional(reversibility),
+  predictionMeta: v.optional(predictionMeta),
+  // Consensus tracking (for non-consensus detection)
+  consensusView: v.optional(consensusView),
+  consensusConfidence: v.optional(v.number()),
+  // 0-1: What we think consensus confidence is
+  consensusSource: v.optional(v.string()),
+  // Where we got the consensus view (twitter, reports, etc.)
+  // --- Evidence ---
+  methodology: v.optional(methodology),
+  informationAsymmetry: v.optional(informationAsymmetry),
+  temporalNature: v.optional(temporalNature),
+  // --- Question ---
+  questionType: v.optional(questionType),
+  questionPriority: v.optional(questionPriority),
+  answerQuality: v.optional(answerQuality),
+  // --- Theme ---
+  themeConviction: v.optional(themeConviction),
+  // Market timing (for "early on theme" detection)
+  marketAwarenessDate: v.optional(v.number()),
+  // When this theme became broadly discussed
+  marketAwarenessSource: v.optional(v.string()),
+  // How we know (first major report, twitter volume spike, etc.)
+  earlySignalIds: v.optional(v.array(v.string())),
+  // globalIds of evidence we had before market awareness
+  // --- Decision ---
+  decisionType: v.optional(decisionType),
+  decisionOutcome: v.optional(decisionOutcome),
+  // === EXTERNAL IDS (for ontological entities) ===
+  externalIds: v.optional(externalIds2),
+  // === PROVENANCE ===
+  sourceType: sourceType2,
+  aiProvider: v.optional(v.string()),
+  // "claude", "gemini", "gpt-4", etc.
+  extractedFromNodeId: v.optional(v.id("epistemicNodes")),
+  // Quick reference to source
+  // === EXTRACTION CONTEXT ===
+  extractionModel: v.optional(v.string()),
+  // "claude-sonnet-4-20250514"
+  extractionPromptName: v.optional(v.string()),
+  // "lucern/extract-evidence"
+  extractionPromptVersion: v.optional(v.number()),
+  extractionTemperature: v.optional(v.number()),
+  extractionLangfuseTraceId: v.optional(v.string()),
+  // === GROUNDING VERIFICATION ===
+  groundingVerified: v.optional(v.boolean()),
+  groundingConfidence: v.optional(v.number()),
+  // 0-1 match quality
+  groundingMatchedText: v.optional(v.string()),
+  // Actual text from source
+  groundingStartOffset: v.optional(v.number()),
+  groundingEndOffset: v.optional(v.number()),
+  groundingRejectionReason: v.optional(v.string()),
+  // === CONFIDENCE & VERIFICATION ===
+  confidence: v.optional(v.number()),
+  // 0-1 projected probability P(x) = b + a*u
+  verificationStatus: v.optional(verificationStatus),
+  // === SL OPINION (Subjective Logic — Kernel v2) ===
+  // Replaces scalar confidence with rich epistemic state.
+  // b + d + u = 1. P(x) = b + a*u is stored in `confidence` for backward compat.
+  opinion_b: v.optional(v.number()),
+  // Belief: evidence FOR (0-1)
+  opinion_d: v.optional(v.number()),
+  // Disbelief: evidence AGAINST (0-1)
+  opinion_u: v.optional(v.number()),
+  // Uncertainty: absence of evidence (0-1)
+  opinion_a: v.optional(v.number()),
+  // Base rate / prior probability (0-1)
+  tupleContradicted: v.optional(v.boolean()),
+  // Single-belief tuple-space contradiction flag
+  // === LIFECYCLE ===
+  status: nodeStatus,
+  supersededBy: v.optional(v.id("epistemicNodes")),
+  // === OWNERSHIP ===
+  topicId: v.optional(v.string()),
+  // Canonical scope container (topic-first model)
+  projectId: v.optional(v.string()),
+  // DEPRECATED: Use belongs_to edges
+  createdBy: v.string(),
+  // Clerk user ID
+  createdAt: v.number(),
+  updatedAt: v.number(),
+  // === NEO4J SYNC STATUS ===
+  syncStatus: v.optional(syncStatus),
+  syncError: v.optional(v.string())
+  // Error message if sync failed
+}).index("by_globalId", ["globalId"]).index("by_contentHash", ["contentHash"]).index("by_nodeType", ["nodeType"]).index("by_subtype", ["nodeType", "subtype"]).index("by_domain", ["domain"]).index("by_project", ["projectId"]).index("by_project_type", ["projectId", "nodeType"]).index("by_topic", ["topicId"]).index("by_topic_type", ["topicId", "nodeType"]).index("by_tenantId", ["tenantId"]).index("by_workspaceId", ["workspaceId"]).index("by_tenant_workspace", ["tenantId", "workspaceId"]).index("by_audienceLabel", ["audienceLabel"]).index("by_sensitivityTier", ["sensitivityTier"]).index("by_exportClass", ["exportClass"]).index("by_status", ["status"]).index("by_sourceType", ["sourceType"]).index("by_verification", ["verificationStatus"]).index("by_layer", ["epistemicLayer"]).index("by_layer_type", ["epistemicLayer", "nodeType"]).index("by_syncStatus", ["syncStatus"]).index("by_publicationStatus", ["publicationStatus"]).index("by_tenant_publicationStatus", ["tenantId", "publicationStatus"]).index("by_belief_status", ["nodeType", "beliefStatus"]).index("by_epistemic_status", ["nodeType", "epistemicStatus"]).index("by_temporal_nature", ["nodeType", "temporalNature"]).index("by_methodology", ["nodeType", "methodology"]).index("by_reversibility", ["nodeType", "reversibility"]).index("by_questionType", ["nodeType", "questionType"]).index("by_questionPriority", ["nodeType", "questionPriority"]).searchIndex("search_canonicalText", {
+  searchField: "canonicalText",
+  filterFields: ["nodeType", "projectId", "topicId", "status"]
+});
+function getLayerForNodeType(type) {
+  switch (type) {
+    case "decision":
+      return "L4";
+    case "belief":
+    case "question":
+    case "theme":
+    case "deal":
+      return "L3";
+    case "claim":
+    case "evidence":
+    case "synthesis":
+    case "answer":
+      return "L2";
+    case "atomic_fact":
+    case "excerpt":
+    case "source":
+      return "L1";
+    case "topic":
+      return "organizational";
+    case "company":
+    case "person":
+    case "investor":
+    case "function":
+    case "value_chain":
+      return "ontological";
+  }
+}
+var api = anyApi;
+componentsGeneric();
+
+// src/topicScope.ts
+var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
+function asMappedProjectId(topic) {
+  if (!topic) {
+    return;
+  }
+  const directLegacyProjectId = normalizeScopeValue(topic[LEGACY_SCOPE_FIELD]);
+  if (directLegacyProjectId) {
+    return directLegacyProjectId;
+  }
+  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;
+  }
+  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_FIELD, scopeId)
+    ).collect();
+  } catch {
+    const topics = await ctx.db.query("topics").collect();
+    return topics.filter((topic) => {
+      const normalizedGlobalId = normalizeScopeValue(topic.globalId);
+      const mappedProjectId = asMappedProjectId(topic);
+      return String(topic._id) === scopeId || normalizedGlobalId === scopeId || mappedProjectId === scopeId;
+    });
+  }
+}
+async function tryResolveHostTopicById(ctx, topicId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.get, {
+      id: topicId
+    }) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function tryResolveHostTopicByLegacyScope(ctx, legacyScopeId) {
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    return await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: legacyScopeId
+    }) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function resolveInheritedWorkspaceScope(ctx, topic) {
+  const MAX_DEPTH = 10;
+  let tenantId = normalizeScopeValue(topic.tenantId);
+  let workspaceId = normalizeScopeValue(topic.workspaceId);
+  if (tenantId && workspaceId) {
+    return { tenantId, workspaceId };
+  }
+  let current = topic;
+  for (let i = 0; i < MAX_DEPTH && current?.parentTopicId; i++) {
+    current = await ctx.db.get(current.parentTopicId);
+    if (!current) break;
+    if (!tenantId) {
+      tenantId = normalizeScopeValue(current.tenantId);
+    }
+    if (!workspaceId) {
+      workspaceId = normalizeScopeValue(current.workspaceId);
+    }
+    if (tenantId && workspaceId) break;
+  }
+  return { tenantId, workspaceId };
+}
+async function resolveTopicProjectScope(ctx, args) {
+  if (args.topicId) {
+    let topic = null;
+    try {
+      topic = await ctx.db.get(args.topicId);
+    } catch {
+    }
+    if (!topic) {
+      topic = await tryResolveHostTopicById(ctx, String(args.topicId));
+    }
+    if (!topic) {
+      topic = pickPrimaryTopic(
+        await findTopicsByScopeAlias(ctx, String(args.topicId))
+      ) ?? null;
+    }
+    if (!topic) {
+      throw new Error(`Topic not found: ${String(args.topicId)}`);
+    }
+    const inherited = await resolveInheritedWorkspaceScope(ctx, topic);
+    const mapped = asMappedProjectId(topic);
+    if (mapped) {
+      return {
+        topicId: topic._id,
+        projectId: mapped,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "topic"
+      };
+    }
+    return {
+      topicId: topic._id,
+      tenantId: inherited.tenantId,
+      workspaceId: inherited.workspaceId,
+      source: "topic"
+    };
+  }
+  if (args.projectId) {
+    let directTopic = null;
+    try {
+      directTopic = await ctx.db.get(
+        args.projectId
+      );
+    } catch {
+    }
+    if (directTopic) {
+      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
+      const mapped = asMappedProjectId(directTopic);
+      return {
+        topicId: directTopic._id,
+        projectId: mapped ?? args.projectId,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "topic_inferred"
+      };
+    }
+    directTopic = await tryResolveHostTopicByLegacyScope(ctx, args.projectId);
+    if (directTopic) {
+      const inherited = await resolveInheritedWorkspaceScope(ctx, directTopic);
+      const mapped = asMappedProjectId(directTopic);
+      return {
+        topicId: directTopic._id,
+        projectId: mapped ?? args.projectId,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "topic_inferred"
+      };
+    }
+    const topics = await findTopicsByScopeAlias(ctx, args.projectId);
+    const primary = pickPrimaryTopic(topics);
+    if (primary) {
+      const inherited = await resolveInheritedWorkspaceScope(ctx, primary);
+      return {
+        topicId: primary._id,
+        projectId: args.projectId,
+        tenantId: inherited.tenantId,
+        workspaceId: inherited.workspaceId,
+        source: "project_mapped_topic"
+      };
+    }
+    throw new Error(
+      `Legacy project scope ${String(args.projectId)} has no mapped topic.`
+    );
+  }
+  throw new Error(
+    "Missing scope: provide topicId (preferred) or legacy projectId alias."
+  );
+}
+({
+  projectId: v.optional(v.string()),
+  topicId: v.optional(v.string())
+});
+
+// src/workspaceIsolation.ts
+function normalizeScopeValue2(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function throwWorkspaceIsolationError(args) {
+  const error = new Error(args.message);
+  error.status = 409;
+  error.code = "INVARIANT_VIOLATION";
+  error.invariantCode = args.invariantCode;
+  error.suggestion = args.suggestion;
+  error.details = args.details;
+  throw error;
+}
+function assertWorkspaceScopedEpistemicNodeScope(args) {
+  const layer = getLayerForNodeType(args.nodeType);
+  if (layer === "ontological") {
+    return;
+  }
+  const workspaceId = normalizeScopeValue2(args.scope.workspaceId);
+  if (workspaceId) {
+    return;
+  }
+  throwWorkspaceIsolationError({
+    message: "Workspace-scoped reasoning isolation requires workspaceId on non-ontological node creation.",
+    invariantCode: "workspace.scope_required_for_epistemic_nodes",
+    suggestion: "Resolve the topic/project scope through a workspace-bound topic before creating epistemic nodes.",
+    details: {
+      mutationName: args.mutationName,
+      nodeType: args.nodeType,
+      topicId: args.scope.topicId,
+      projectId: args.scope.projectId
+    }
+  });
+}
+function nodeMatchesWorkspaceReasoningScope(node, scope) {
+  if (!node) {
+    return false;
+  }
+  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
+  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
+  const nodeTenantId = normalizeScopeValue2(node.tenantId);
+  const nodeWorkspaceId = normalizeScopeValue2(node.workspaceId);
+  const epistemicLayer2 = typeof node.epistemicLayer === "string" ? node.epistemicLayer : void 0;
+  if (scopeTenantId && nodeTenantId && scopeTenantId !== nodeTenantId) {
+    return false;
+  }
+  if (epistemicLayer2 === "ontological" && nodeWorkspaceId === void 0) {
+    return true;
+  }
+  if (!scopeWorkspaceId && node.publicationStatus === "published") {
+    return true;
+  }
+  if (!scopeWorkspaceId) {
+    return nodeWorkspaceId === void 0;
+  }
+  return scopeWorkspaceId === nodeWorkspaceId;
+}
+function edgeMatchesWorkspaceReasoningScope(edge, scope) {
+  if (!edge) {
+    return false;
+  }
+  const scopeTenantId = normalizeScopeValue2(scope.tenantId);
+  const scopeWorkspaceId = normalizeScopeValue2(scope.workspaceId);
+  const edgeTenantId = normalizeScopeValue2(edge.tenantId);
+  const edgeWorkspaceId = normalizeScopeValue2(edge.workspaceId);
+  if (scopeTenantId && edgeTenantId && scopeTenantId !== edgeTenantId) {
+    return false;
+  }
+  if (!scopeWorkspaceId) {
+    return edgeWorkspaceId === void 0;
+  }
+  return scopeWorkspaceId === edgeWorkspaceId;
+}
+async function resolveNodeScopeForWorkspaceIsolation(ctx, node) {
+  const epistemicLayer2 = typeof node?.epistemicLayer === "string" ? node.epistemicLayer : void 0;
+  const resolved = {
+    tenantId: normalizeScopeValue2(node?.tenantId),
+    workspaceId: normalizeScopeValue2(node?.workspaceId),
+    epistemicLayer: epistemicLayer2,
+    nodeType: typeof node?.nodeType === "string" ? node.nodeType : void 0
+  };
+  if (!node) {
+    return resolved;
+  }
+  if (resolved.epistemicLayer === "ontological") {
+    return resolved;
+  }
+  if (resolved.tenantId || resolved.workspaceId) {
+    return resolved;
+  }
+  if (node.topicId) {
+    const topicScope = await resolveTopicProjectScope(ctx, {
+      topicId: node.topicId
+    });
+    return {
+      ...resolved,
+      tenantId: topicScope.tenantId,
+      workspaceId: topicScope.workspaceId
+    };
+  }
+  if (node.projectId) {
+    const topicScope = await resolveTopicProjectScope(ctx, {
+      projectId: String(node.projectId)
+    });
+    return {
+      ...resolved,
+      tenantId: topicScope.tenantId,
+      workspaceId: topicScope.workspaceId
+    };
+  }
+  return resolved;
+}
+function resolveRuntimePackMutationContext(args) {
+  if (!args.runtimeToolName && !args.runtimePackKey && !args.runtimePackInstallScope) {
+    return;
+  }
+  return {
+    toolName: args.runtimeToolName,
+    packKey: args.runtimePackKey,
+    packInstallScope: args.runtimePackInstallScope
+  };
+}
+function assertTenantPackWorkspaceMutationAllowed(args) {
+  if (!args.runtime?.packKey || args.runtime.packInstallScope !== "tenant") {
+    return;
+  }
+  const targetWorkspaceId = normalizeScopeValue2(args.target.workspaceId);
+  const targetLayer = typeof args.target.epistemicLayer === "string" ? args.target.epistemicLayer : void 0;
+  if (!targetWorkspaceId || targetLayer === "ontological") {
+    return;
+  }
+  throwWorkspaceIsolationError({
+    message: `Tenant-scoped pack "${args.runtime.packKey}" cannot mutate workspace-scoped reasoning state.`,
+    invariantCode: "workspace.tenant_pack_reasoning_write_forbidden",
+    suggestion: "Use a workspace-scoped pack for workspace-local graph mutations, or route the change through tenant-global canonical entity flows.",
+    details: {
+      mutationName: args.mutationName,
+      toolName: args.runtime.toolName,
+      packKey: args.runtime.packKey,
+      targetWorkspaceId,
+      targetNodeType: args.target.nodeType,
+      targetLayer
+    }
+  });
+}
+
+export { assertTenantPackWorkspaceMutationAllowed, assertWorkspaceScopedEpistemicNodeScope, edgeMatchesWorkspaceReasoningScope, nodeMatchesWorkspaceReasoningScope, normalizeScopeValue2 as normalizeScopeValue, resolveNodeScopeForWorkspaceIsolation, resolveRuntimePackMutationContext };
+//# sourceMappingURL=workspaceIsolation.js.map
+//# sourceMappingURL=workspaceIsolation.js.map