@lucern/graph-primitives 0.1.0-alpha.2

package/dist/beliefDecay.js

@@ -0,0 +1,1628 @@
+import { v } from 'convex/values';
+import { componentsGeneric, queryGeneric, anyApi } from 'convex/server';
+
+// src/beliefDecay.ts
+
+// ../confidence/src/v1/operations/subjectiveLogic/index.ts
+function project(o) {
+  return o.b + o.a * o.u;
+}
+
+// ../confidence/src/v1/operations/bridge/index.ts
+var DEFAULT_NON_INFORMATIVE_WEIGHT = 2;
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function clampNonNegative(value) {
+  return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function normalizeNonInformativeWeight(weight) {
+  if (weight === void 0) {
+    return DEFAULT_NON_INFORMATIVE_WEIGHT;
+  }
+  return Number.isFinite(weight) ? Math.max(0, weight) : DEFAULT_NON_INFORMATIVE_WEIGHT;
+}
+function normalizeBaseRateVector(baseRate, size) {
+  if (size === 0) {
+    return [];
+  }
+  const fallback = Array.from({ length: size }, () => 1 / size);
+  if (!baseRate) {
+    return fallback;
+  }
+  if (baseRate.length !== size) {
+    throw new Error(
+      `Base-rate vector length ${baseRate.length} must match evidence vector length ${size}.`
+    );
+  }
+  const normalized = baseRate.map((value) => clampNonNegative(value));
+  const total = normalized.reduce((sum, value) => sum + value, 0);
+  if (total === 0) {
+    return fallback;
+  }
+  return normalized.map((value) => value / total);
+}
+function opinionFromDirichlet(alpha, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT, baseRate) {
+  const evidence = alpha.map((value) => clampNonNegative(value));
+  const safeWeight = normalizeNonInformativeWeight(nonInformativeWeight);
+  const normalizedBaseRate = normalizeBaseRateVector(baseRate, evidence.length);
+  const totalEvidence = evidence.reduce((sum, value) => sum + value, 0);
+  const denominator = totalEvidence + safeWeight;
+  if (denominator === 0) {
+    return {
+      b: evidence.map(() => 0),
+      u: 1,
+      a: normalizedBaseRate
+    };
+  }
+  return {
+    b: evidence.map((value) => value / denominator),
+    u: safeWeight / denominator,
+    a: normalizedBaseRate
+  };
+}
+function opinionFromBeta(alpha, beta, nonInformativeWeight = DEFAULT_NON_INFORMATIVE_WEIGHT, baseRate = 0.5) {
+  const dirichlet = opinionFromDirichlet(
+    [alpha, beta],
+    nonInformativeWeight,
+    [clamp01(baseRate), 1 - clamp01(baseRate)]
+  );
+  return {
+    b: dirichlet.b[0] ?? 0,
+    d: dirichlet.b[1] ?? 0,
+    u: dirichlet.u,
+    a: dirichlet.a[0] ?? clamp01(baseRate)
+  };
+}
+
+// ../confidence/src/v1/operations/dynamics/revision.ts
+function clamp012(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function toEvidence(probability, weight) {
+  const safeProbability = clamp012(probability);
+  const safeWeight = Number.isFinite(weight) ? Math.max(0, weight) : 0;
+  return {
+    alpha: safeProbability * safeWeight,
+    beta: (1 - safeProbability) * safeWeight
+  };
+}
+function bayesianUpdate(priorConfidence, priorWeight, newAssessment, newWeight, options) {
+  return reviseConfidence({
+    priorConfidence,
+    priorWeight,
+    newAssessment,
+    newWeight,
+    baseRate: options?.baseRate,
+    nonInformativeWeight: options?.nonInformativeWeight
+  });
+}
+function reviseConfidence(args) {
+  return project(reviseConfidenceOpinion(args));
+}
+function reviseConfidenceOpinion(args) {
+  const priorEvidence = toEvidence(args.priorConfidence, args.priorWeight);
+  const newEvidence = toEvidence(args.newAssessment, args.newWeight ?? 1);
+  return opinionFromBeta(
+    priorEvidence.alpha + newEvidence.alpha,
+    priorEvidence.beta + newEvidence.beta,
+    args.nonInformativeWeight ?? DEFAULT_NON_INFORMATIVE_WEIGHT,
+    args.baseRate ?? 0.5
+  );
+}
+
+// ../confidence/src/v1/operations/dynamics/decay.ts
+var DECAY_TIERS = {
+  FRESH: {
+    maxAgeDays: 30,
+    weight: 1,
+    label: "fresh",
+    action: "Full confidence \u2014 recently validated",
+    rescoreInDays: 30
+  },
+  AGING: {
+    maxAgeDays: 90,
+    weight: 0.8,
+    label: "aging",
+    action: "Evidence refresh recommended",
+    rescoreInDays: 14
+  },
+  STALE: {
+    maxAgeDays: 180,
+    weight: 0.5,
+    label: "stale",
+    action: "Evidence update required before trusting",
+    rescoreInDays: 7
+  },
+  EXPIRED: {
+    maxAgeDays: Number.POSITIVE_INFINITY,
+    weight: 0.2,
+    label: "expired",
+    action: "Full re-evaluation needed",
+    rescoreInDays: 0
+  }
+};
+var DEADLINE_URGENCY = {
+  DISTANT: {
+    minDaysToDeadline: 365,
+    urgencyMultiplier: 1,
+    label: "distant",
+    rescoreIntervalDays: 90,
+    action: "Quarterly confidence check"
+  },
+  APPROACHING: {
+    minDaysToDeadline: 180,
+    urgencyMultiplier: 0.9,
+    label: "approaching",
+    rescoreIntervalDays: 30,
+    action: "Monthly confidence check \u2014 conditions may be shifting"
+  },
+  NEAR: {
+    minDaysToDeadline: 90,
+    urgencyMultiplier: 0.75,
+    label: "near",
+    rescoreIntervalDays: 14,
+    action: "Biweekly rescore \u2014 deadline within 3 months"
+  },
+  IMMINENT: {
+    minDaysToDeadline: 30,
+    urgencyMultiplier: 0.6,
+    label: "imminent",
+    rescoreIntervalDays: 7,
+    action: "Weekly rescore \u2014 deadline within 1 month"
+  },
+  CRITICAL: {
+    minDaysToDeadline: 7,
+    urgencyMultiplier: 0.4,
+    label: "critical",
+    rescoreIntervalDays: 1,
+    action: "Daily rescore \u2014 deadline THIS WEEK"
+  },
+  OVERDUE: {
+    minDaysToDeadline: Number.NEGATIVE_INFINITY,
+    urgencyMultiplier: 0.2,
+    label: "overdue",
+    rescoreIntervalDays: 0,
+    action: "OVERDUE \u2014 must validate or archive immediately"
+  }
+};
+function normalizeBeliefConfidence(confidence) {
+  if (typeof confidence !== "number" || !Number.isFinite(confidence)) {
+    return null;
+  }
+  if (confidence >= 0 && confidence <= 1) {
+    return confidence;
+  }
+  if (confidence > 1 && confidence <= 100) {
+    return confidence / 100;
+  }
+  return null;
+}
+function hasResolvedPredictionOutcome(predictionMeta) {
+  if (!predictionMeta || typeof predictionMeta !== "object") {
+    return false;
+  }
+  const outcome = predictionMeta.outcome;
+  return outcome === "confirmed" || outcome === "disconfirmed" || outcome === "partial" || outcome === "expired";
+}
+function resolveLifecycleBucket(args) {
+  if (normalizeBeliefConfidence(args.confidence) === 0 || normalizeBeliefConfidence(args.confidence) === 1 || hasResolvedPredictionOutcome(args.predictionMeta)) {
+    return "fact";
+  }
+  if (args.beliefStatus === "assumption" || args.beliefStatus === "hypothesis" || args.beliefStatus === "belief" || args.beliefStatus === "fact") {
+    if (normalizeBeliefConfidence(args.confidence) !== null && (args.beliefStatus === "assumption" || args.beliefStatus === "hypothesis")) {
+      return "belief";
+    }
+    return args.beliefStatus;
+  }
+  return "assumption";
+}
+function lifecycleMultiplier(status) {
+  if (status === "assumption") {
+    return 0.65;
+  }
+  if (status === "hypothesis") {
+    return 0.8;
+  }
+  return 1;
+}
+function computeBaseDecay(lastScoredAt) {
+  const ageDays = (Date.now() - lastScoredAt) / (1e3 * 60 * 60 * 24);
+  let tier = DECAY_TIERS.EXPIRED;
+  if (ageDays <= DECAY_TIERS.FRESH.maxAgeDays) {
+    tier = DECAY_TIERS.FRESH;
+  } else if (ageDays <= DECAY_TIERS.AGING.maxAgeDays) {
+    tier = DECAY_TIERS.AGING;
+  } else if (ageDays <= DECAY_TIERS.STALE.maxAgeDays) {
+    tier = DECAY_TIERS.STALE;
+  }
+  return { ageDays, tier, weight: tier.weight };
+}
+function computeDeadlineUrgency(expectedBy) {
+  if (!expectedBy) {
+    return null;
+  }
+  const daysToDeadline = (expectedBy - Date.now()) / (1e3 * 60 * 60 * 24);
+  let urgencyTier = DEADLINE_URGENCY.DISTANT;
+  if (daysToDeadline < 0) {
+    urgencyTier = DEADLINE_URGENCY.OVERDUE;
+  } else if (daysToDeadline <= 7) {
+    urgencyTier = DEADLINE_URGENCY.CRITICAL;
+  } else if (daysToDeadline <= 30) {
+    urgencyTier = DEADLINE_URGENCY.IMMINENT;
+  } else if (daysToDeadline <= 90) {
+    urgencyTier = DEADLINE_URGENCY.NEAR;
+  } else if (daysToDeadline <= 180) {
+    urgencyTier = DEADLINE_URGENCY.APPROACHING;
+  }
+  return {
+    daysToDeadline: Math.round(daysToDeadline),
+    urgencyTier,
+    urgencyMultiplier: urgencyTier.urgencyMultiplier,
+    isOverdue: daysToDeadline < 0
+  };
+}
+function computeEffectiveDecay(lastScoredAt, expectedBy, beliefStatus) {
+  const base = computeBaseDecay(lastScoredAt);
+  const urgency = computeDeadlineUrgency(expectedBy);
+  const effectiveWeight = (urgency ? base.weight * urgency.urgencyMultiplier : base.weight) * lifecycleMultiplier(beliefStatus);
+  const urgencyRescoreDays = urgency?.urgencyTier.rescoreIntervalDays ?? Number.POSITIVE_INFINITY;
+  const rescoreInDays = Math.min(base.tier.rescoreInDays, urgencyRescoreDays);
+  const rescoreByDate = lastScoredAt + rescoreInDays * 24 * 60 * 60 * 1e3;
+  let action = base.tier.action;
+  if (urgency && urgency.urgencyTier.label !== "distant") {
+    action = `${urgency.urgencyTier.action}. ${base.tier.action}`;
+  }
+  return {
+    ageDays: base.ageDays,
+    baseTier: base.tier,
+    baseWeight: base.weight,
+    urgency,
+    effectiveWeight: Math.max(0, Math.min(1, effectiveWeight)),
+    rescoreByDate,
+    rescoreInDays,
+    action
+  };
+}
+function getRescoringSchedule(opts) {
+  const lifecycleStatus = resolveLifecycleBucket({
+    beliefStatus: opts.beliefStatus,
+    confidence: opts.confidence,
+    predictionMeta: opts.predictionMeta
+  });
+  const decayState = computeEffectiveDecay(
+    opts.lastScoredAt,
+    opts.expectedBy,
+    lifecycleStatus
+  );
+  const daysUntilRescore = (decayState.rescoreByDate - Date.now()) / (1e3 * 60 * 60 * 24);
+  const isOverdue = daysUntilRescore < 0;
+  let priority;
+  let reason;
+  if (isOverdue && lifecycleStatus === "assumption") {
+    priority = "critical";
+    reason = `Untested assumption is stale (${Math.round(decayState.ageDays)}d) \u2014 validate or supersede`;
+  } else if (isOverdue && lifecycleStatus === "hypothesis" || lifecycleStatus === "hypothesis" && daysUntilRescore < 7) {
+    priority = "high";
+    reason = `Hypothesis aging without validation (${Math.round(decayState.ageDays)}d) \u2014 run/finish sprint testing`;
+  } else if (decayState.urgency?.isOverdue) {
+    priority = "critical";
+    reason = `Prediction deadline passed ${Math.abs(decayState.urgency.daysToDeadline)}d ago \u2014 validate or archive`;
+  } else if (isOverdue && decayState.baseTier.label === "expired") {
+    priority = "critical";
+    reason = `Not scored in ${Math.round(decayState.ageDays)}d \u2014 confidence severely degraded`;
+  } else if (isOverdue && decayState.baseTier.label === "stale") {
+    priority = "high";
+    reason = `Stale (${Math.round(decayState.ageDays)}d since scoring) \u2014 evidence update required`;
+  } else if (decayState.urgency && decayState.urgency.urgencyTier.label === "critical") {
+    priority = "critical";
+    reason = `Deadline in ${decayState.urgency.daysToDeadline}d \u2014 needs immediate rescoring`;
+  } else if (decayState.urgency && decayState.urgency.urgencyTier.label === "imminent") {
+    priority = "high";
+    reason = `Deadline in ${decayState.urgency.daysToDeadline}d \u2014 weekly rescoring required`;
+  } else if (isOverdue) {
+    priority = "high";
+    reason = `Rescore overdue by ${Math.abs(Math.round(daysUntilRescore))}d`;
+  } else if (opts.temporalNature === "forecast" && daysUntilRescore < 7) {
+    priority = "medium";
+    reason = `Forecast belief \u2014 next rescore due in ${Math.round(daysUntilRescore)}d`;
+  } else if (daysUntilRescore < 14) {
+    priority = "medium";
+    reason = `Rescore due in ${Math.round(daysUntilRescore)}d`;
+  } else {
+    priority = "low";
+    reason = `On schedule \u2014 next rescore in ${Math.round(daysUntilRescore)}d`;
+  }
+  if ((opts.confidence ?? 0) >= 0.8 && decayState.baseTier.label !== "fresh" && priority === "medium") {
+    priority = "high";
+    reason = `High-confidence belief (${((opts.confidence ?? 0) * 100).toFixed(0)}%) aging without rescore \u2014 ${reason}`;
+  }
+  return {
+    nextRescoreBy: decayState.rescoreByDate,
+    daysUntilRescore: Math.round(daysUntilRescore),
+    isOverdue,
+    priority,
+    reason,
+    decay: decayState
+  };
+}
+var api = anyApi;
+componentsGeneric();
+
+// ../access-control/src/topicProjectOverlay.ts
+var LEGACY_SCOPE_FIELD = "graphScopeProjectId";
+function readNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => readNonEmptyString(entry)).filter((entry) => Boolean(entry));
+}
+function readMetadata(topic) {
+  return topic.metadata && typeof topic.metadata === "object" ? topic.metadata : {};
+}
+function readLegacyProjectId(value) {
+  if (!value) {
+    return;
+  }
+  return readNonEmptyString(value[LEGACY_SCOPE_FIELD]);
+}
+function coerceVisibility(value) {
+  return value === "private" || value === "team" || value === "firm" || value === "external" || value === "public" ? value : void 0;
+}
+function coerceStatus(value) {
+  return value === "active" || value === "archived" || value === "watching" ? value : void 0;
+}
+function mapProjectType(topic, metadata) {
+  const explicit = readNonEmptyString(metadata.projectType);
+  if (explicit) {
+    return explicit;
+  }
+  if (topic.type === "theme") {
+    return "thematic";
+  }
+  return readNonEmptyString(topic.type) || "general";
+}
+function isProjectLikeTopic(topic) {
+  const metadata = readMetadata(topic);
+  return topic.type === "theme" || topic.type === "thematic" || topic.type === "deal" || topic.type === "monitoring" || readLegacyProjectId(topic) !== void 0 || readNonEmptyString(metadata.projectType) !== void 0;
+}
+async function resolveTopicDoc(ctx, scopeId) {
+  if (ctx?.db && typeof ctx.db.get === "function") {
+    try {
+      const directTopic = await ctx.db.get(scopeId);
+      if (directTopic) {
+        return directTopic;
+      }
+    } catch {
+    }
+  }
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    const topic = await ctx.runQuery(api.topics.get, {
+      id: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch {
+  }
+  try {
+    const topic = await ctx.runQuery(api.topics.getByLegacyScopeId, {
+      projectId: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch {
+  }
+  return null;
+}
+function materializeTopicProjectOverlay(topic, idMode = "legacy") {
+  const metadata = readMetadata(topic);
+  const topicId = String(topic._id);
+  const legacyProjectId = readLegacyProjectId(topic) || readLegacyProjectId(metadata) || readNonEmptyString(metadata.legacyProjectId);
+  const storageProjectId = legacyProjectId || topicId;
+  const outwardId = idMode === "topic" ? topicId : storageProjectId;
+  const visibility = coerceVisibility(topic.visibility) || coerceVisibility(metadata.visibility) || "private";
+  const status = coerceStatus(topic.status) || coerceStatus(metadata.status) || "active";
+  const createdAt = typeof topic.createdAt === "number" ? topic.createdAt : typeof topic._creationTime === "number" ? topic._creationTime : 0;
+  const updatedAt = typeof topic.updatedAt === "number" ? topic.updatedAt : typeof metadata.updatedAt === "number" ? metadata.updatedAt : createdAt;
+  return {
+    ...metadata,
+    _id: outwardId,
+    projectId: outwardId,
+    topicId,
+    storageProjectId,
+    legacyProjectId,
+    name: readNonEmptyString(topic.name) || "Untitled Theme",
+    type: mapProjectType(topic, metadata),
+    description: readNonEmptyString(topic.description),
+    ownerId: readNonEmptyString(metadata.ownerId) || readNonEmptyString(topic.createdBy) || "system",
+    sharedWith: readStringArray(metadata.sharedWith),
+    visibility,
+    tenantId: readNonEmptyString(topic.tenantId) || readNonEmptyString(metadata.tenantId),
+    workspaceId: readNonEmptyString(topic.workspaceId) || readNonEmptyString(metadata.workspaceId),
+    status,
+    tags: readStringArray(metadata.tags),
+    chatCount: typeof metadata.chatCount === "number" ? metadata.chatCount : 0,
+    artifactCount: typeof metadata.artifactCount === "number" ? metadata.artifactCount : 0,
+    lastActivityAt: typeof metadata.lastActivityAt === "number" ? metadata.lastActivityAt : updatedAt,
+    _creationTime: typeof topic._creationTime === "number" ? topic._creationTime : createdAt,
+    createdAt,
+    updatedAt
+  };
+}
+async function resolveTopicProjectOverlay(ctx, scopeId, options = {}) {
+  const topic = await resolveTopicDoc(ctx, scopeId);
+  if (!topic) {
+    return null;
+  }
+  if (options.projectLikeOnly !== false && !isProjectLikeTopic(topic)) {
+    return null;
+  }
+  return materializeTopicProjectOverlay(topic, options.idMode);
+}
+async function listTopicProjectOverlays(ctx, options = {}) {
+  let allTopics = [];
+  if (ctx?.db?.query && typeof ctx.db.query === "function") {
+    try {
+      allTopics = await ctx.db.query("topics").collect();
+    } catch {
+      allTopics = [];
+    }
+  }
+  if (allTopics.length === 0 && typeof ctx.runQuery === "function") {
+    allTopics = (await ctx.runQuery(api.topics.list, {}) ?? []) || [];
+  }
+  return allTopics.filter(
+    (topic) => options.projectLikeOnly === false || isProjectLikeTopic(topic)
+  ).map((topic) => materializeTopicProjectOverlay(topic, options.idMode));
+}
+
+// ../access-control/src/projectGrantsBridge.ts
+var PROJECT_GRANT_STATUSES = ["active", "revoked", "expired"];
+function normalizeString(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+async function resolveGrantScopeIds(ctx, args) {
+  const topicId = normalizeString(args.topicId);
+  const projectId = normalizeString(args.projectId);
+  for (const scopeId of [topicId, projectId]) {
+    if (!scopeId) {
+      continue;
+    }
+    try {
+      const overlay = await resolveTopicProjectOverlay(ctx, scopeId, {
+        idMode: "legacy",
+        projectLikeOnly: false
+      });
+      if (overlay) {
+        return {
+          topicId: normalizeString(overlay.topicId) ?? topicId,
+          projectId: normalizeString(overlay.projectId) ?? projectId ?? scopeId
+        };
+      }
+    } catch {
+    }
+  }
+  return { topicId, projectId };
+}
+async function normalizeProjectGrantRow(ctx, row) {
+  const scope = await resolveGrantScopeIds(ctx, {
+    topicId: row.topicId,
+    projectId: row.projectId
+  });
+  return {
+    ...row,
+    ...scope.topicId ? { topicId: scope.topicId } : {},
+    ...scope.projectId ?? scope.topicId ? { projectId: scope.projectId ?? scope.topicId } : {}
+  };
+}
+async function normalizeProjectGrantRows(ctx, rows) {
+  return await Promise.all(rows.map((row) => normalizeProjectGrantRow(ctx, row)));
+}
+async function listProjectGrantsByPrincipal(ctx, principalId) {
+  const rows = await Promise.all(
+    PROJECT_GRANT_STATUSES.map(
+      (status) => ctx.db.query("projectGrants").withIndex(
+        "by_principal_status",
+        (q) => q.eq("principalId", principalId).eq("status", status)
+      ).collect()
+    )
+  );
+  return await normalizeProjectGrantRows(ctx, rows.flat());
+}
+async function listProjectGrantsByGroup(ctx, groupId) {
+  const rows = await Promise.all(
+    PROJECT_GRANT_STATUSES.map(
+      (status) => ctx.db.query("projectGrants").withIndex(
+        "by_group_status",
+        (q) => q.eq("groupId", groupId).eq("status", status)
+      ).collect()
+    )
+  );
+  return await normalizeProjectGrantRows(ctx, rows.flat());
+}
+function buildScopeMatchers(inputScopeId, resolved) {
+  return new Set(
+    [inputScopeId, resolved.topicId, resolved.projectId].map((value) => normalizeString(value)).filter((value) => Boolean(value))
+  );
+}
+function matchesResolvedScope(row, scopeIds) {
+  const rowTopicId = normalizeString(row.topicId);
+  const rowProjectId = normalizeString(row.projectId);
+  return rowTopicId !== void 0 && scopeIds.has(rowTopicId) || rowProjectId !== void 0 && scopeIds.has(rowProjectId);
+}
+async function bridgeListProjectGrantsByTopicAndPrincipal(ctx, topicId, principalId) {
+  const resolved = await resolveGrantScopeIds(ctx, { topicId });
+  const scopeIds = buildScopeMatchers(topicId, resolved);
+  const rows = await listProjectGrantsByPrincipal(ctx, principalId);
+  return rows.filter((row) => matchesResolvedScope(row, scopeIds));
+}
+async function bridgeListProjectGrantsByTopicAndGroup(ctx, topicId, groupId) {
+  const resolved = await resolveGrantScopeIds(ctx, { topicId });
+  const scopeIds = buildScopeMatchers(topicId, resolved);
+  const rows = await listProjectGrantsByGroup(ctx, groupId);
+  return rows.filter((row) => matchesResolvedScope(row, scopeIds));
+}
+async function bridgeListProjectGrantsByPrincipalStatus(ctx, principalId, status) {
+  const rows = await listProjectGrantsByPrincipal(ctx, principalId);
+  return rows.filter((row) => row.status === status);
+}
+async function bridgeListProjectGrantsByGroupStatus(ctx, groupId, status) {
+  const rows = await listProjectGrantsByGroup(ctx, groupId);
+  return rows.filter((row) => row.status === status);
+}
+async function bridgeInsertProjectGrant(ctx, value) {
+  const resolved = await resolveGrantScopeIds(ctx, value);
+  return await ctx.db.insert("projectGrants", {
+    ...value,
+    ...resolved.topicId ? { topicId: resolved.topicId } : {},
+    ...resolved.projectId ?? resolved.topicId ? { projectId: resolved.projectId ?? resolved.topicId } : {}
+  });
+}
+
+// ../access-control/src/resolvers.ts
+async function findUserByClerkId(ctx, clerkId) {
+  const normalizedClerkId = clerkId.trim();
+  if (!normalizedClerkId) {
+    return null;
+  }
+  if (typeof ctx.runQuery === "function") {
+    try {
+      const bridgedUser = await ctx.runQuery(api.users.getUserByClerkId, {
+        clerkId: normalizedClerkId
+      });
+      if (bridgedUser) {
+        return bridgedUser;
+      }
+    } catch {
+    }
+  }
+  try {
+    const users = await ctx.db.query("users").collect();
+    return users.find((user) => String(user.clerkId ?? "") === normalizedClerkId) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function findUserByPrincipalId(ctx, principalId) {
+  const normalizedPrincipalId = principalId.trim();
+  if (!normalizedPrincipalId) {
+    return null;
+  }
+  try {
+    const users = await ctx.db.query("users").collect();
+    return users.find(
+      (user) => String(user.defaultPrincipalId ?? "") === normalizedPrincipalId
+    ) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function findAgentByPrincipalId(ctx, principalId) {
+  const normalizedPrincipalId = principalId.trim();
+  if (!normalizedPrincipalId) {
+    return null;
+  }
+  if (typeof ctx.runQuery === "function") {
+    try {
+      const bridgedAgent = await ctx.runQuery(
+        api.agents.getAgentByPrincipalId,
+        {
+          principalId: normalizedPrincipalId
+        }
+      );
+      if (bridgedAgent) {
+        return bridgedAgent;
+      }
+    } catch {
+    }
+  }
+  try {
+    const agents = await ctx.db.query("agents").collect();
+    return agents.find(
+      (agent) => String(agent.principalId ?? "") === normalizedPrincipalId
+    ) ?? null;
+  } catch {
+    return null;
+  }
+}
+function defaultResolvers() {
+  return {
+    async getProject(ctx, topicId) {
+      return await resolveTopicProjectOverlay(ctx, topicId, {
+        idMode: "legacy",
+        projectLikeOnly: false
+      });
+    },
+    async listTopics(ctx) {
+      return await listTopicProjectOverlays(ctx, { idMode: "legacy" });
+    },
+    async listTopicsByOwner(ctx, ownerId) {
+      const topics = await listTopicProjectOverlays(ctx, { idMode: "legacy" });
+      return topics.filter((topic) => topic.ownerId === ownerId);
+    },
+    async listTopicsByVisibility(ctx, visibility) {
+      const topics = await listTopicProjectOverlays(ctx, { idMode: "legacy" });
+      return topics.filter((topic) => topic.visibility === visibility);
+    },
+    async listProjectGrantsByProjectAndPrincipal(ctx, topicId, principalId) {
+      return await bridgeListProjectGrantsByTopicAndPrincipal(
+        ctx,
+        topicId,
+        principalId
+      );
+    },
+    async listProjectGrantsByProjectAndGroup(ctx, topicId, groupId) {
+      return await bridgeListProjectGrantsByTopicAndGroup(ctx, topicId, groupId);
+    },
+    async listProjectGrantsByPrincipalStatus(ctx, principalId, status) {
+      return await bridgeListProjectGrantsByPrincipalStatus(
+        ctx,
+        principalId,
+        status
+      );
+    },
+    async listProjectGrantsByGroupStatus(ctx, groupId, status) {
+      return await bridgeListProjectGrantsByGroupStatus(ctx, groupId, status);
+    },
+    async insertProjectGrant(ctx, value) {
+      return await bridgeInsertProjectGrant(ctx, value);
+    },
+    async getAgentByPrincipalId(ctx, principalId) {
+      return await findAgentByPrincipalId(ctx, principalId);
+    },
+    async getUserByClerkId(ctx, clerkId) {
+      return await findUserByClerkId(ctx, clerkId);
+    },
+    async getUserByPrincipalId(ctx, principalId) {
+      return await findUserByPrincipalId(ctx, principalId);
+    }
+  };
+}
+var resolverOverrides = {};
+function resolveAccessControlAppResolvers(_ctx) {
+  return {
+    ...defaultResolvers(),
+    ...resolverOverrides
+  };
+}
+
+// ../access-control/src/principalContext.ts
+function requireCanonicalResolvedUser(user, clerkId) {
+  const resolved = user;
+  if (!resolved) {
+    throw new Error(
+      `[AccessControl] Canonical user identity required for ${clerkId}. Sync users.upsertUser before user-bound access checks.`
+    );
+  }
+  const { mcRole, defaultTenantId, defaultWorkspaceId, defaultPrincipalId } = resolved;
+  if (mcRole !== "platform_admin" && mcRole !== "tenant_admin" && mcRole !== "workspace_admin" && mcRole !== "editor" && mcRole !== "viewer" && mcRole !== "auditor" && mcRole !== "service_agent") {
+    throw new Error(
+      `[AccessControl] Canonical MC role required for ${clerkId}. Re-sync Master Control identity before user-bound access checks.`
+    );
+  }
+  if (typeof defaultTenantId !== "string" || defaultTenantId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical home tenant required for ${clerkId}. Re-sync Master Control identity before user-bound access checks.`
+    );
+  }
+  if (typeof defaultWorkspaceId !== "string" || defaultWorkspaceId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical home workspace required for ${clerkId}. Re-sync Master Control identity before user-bound access checks.`
+    );
+  }
+  if (typeof defaultPrincipalId !== "string" || defaultPrincipalId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical federated principal required for ${clerkId}. Re-sync Master Control identity before user-bound access checks.`
+    );
+  }
+  return {
+    mcRole,
+    defaultTenantId: defaultTenantId.trim(),
+    defaultWorkspaceId: defaultWorkspaceId.trim(),
+    defaultPrincipalId: defaultPrincipalId.trim()
+  };
+}
+function isPrincipalIdInput(value) {
+  return value.startsWith("user:") || value.startsWith("group:") || value.startsWith("service:") || value.startsWith("agent:") || value.startsWith("external_viewer:");
+}
+async function resolveCanonicalUserRecord(ctx, actorId) {
+  const normalizedActorId = actorId.trim();
+  const clerkId = isPrincipalIdInput(normalizedActorId) && normalizedActorId.startsWith("user:") ? normalizedActorId.slice("user:".length) : normalizedActorId;
+  const resolvers = resolveAccessControlAppResolvers();
+  const resolvedByClerkId = await resolvers.getUserByClerkId(ctx, clerkId);
+  if (resolvedByClerkId) {
+    return {
+      resolvedUser: resolvedByClerkId,
+      clerkId,
+      contextClerkId: clerkId
+    };
+  }
+  const resolvedByPrincipalId = await resolvers.getUserByPrincipalId(
+    ctx,
+    normalizedActorId
+  );
+  return {
+    resolvedUser: resolvedByPrincipalId ?? null,
+    clerkId,
+    contextClerkId: normalizedActorId.startsWith("user:") && clerkId.length > 0 ? clerkId : normalizedActorId
+  };
+}
+function uniqRoles(roles) {
+  const roleSet = /* @__PURE__ */ new Set();
+  for (const role of roles) {
+    if (role === "platform_admin" || role === "tenant_admin" || role === "workspace_admin" || role === "editor" || role === "viewer" || role === "auditor" || role === "service_agent") {
+      roleSet.add(role);
+    }
+  }
+  return [...roleSet];
+}
+function normalizeGroupIds(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return [...new Set(
+    value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean)
+  )];
+}
+function requireServiceAgentUser(user, actorId) {
+  const canonicalUser = requireCanonicalResolvedUser(user, actorId);
+  if (canonicalUser.mcRole !== "service_agent") {
+    throw new Error(
+      `[AccessControl] Canonical service_agent identity required for ${actorId}. Sync users.upsertUser before agent-bound access checks.`
+    );
+  }
+  return canonicalUser;
+}
+function requireCanonicalResolvedAgent(agent, actorId) {
+  const resolved = agent;
+  if (!resolved) {
+    throw new Error(
+      `[AccessControl] Agent "${actorId}" not found in agents or users table.`
+    );
+  }
+  if (typeof resolved.principalId !== "string" || resolved.principalId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical agent principalId required for ${actorId}.`
+    );
+  }
+  if (typeof resolved.tenantId !== "string" || resolved.tenantId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical home tenant required for ${actorId}.`
+    );
+  }
+  if (typeof resolved.workspaceId !== "string" || resolved.workspaceId.trim().length === 0) {
+    throw new Error(
+      `[AccessControl] Canonical home workspace required for ${actorId}.`
+    );
+  }
+  return {
+    principalId: resolved.principalId.trim(),
+    tenantId: resolved.tenantId.trim(),
+    workspaceId: resolved.workspaceId.trim(),
+    roles: uniqRoles(Array.isArray(resolved.roles) ? resolved.roles : []) ?? ["service_agent"],
+    groupIds: normalizeGroupIds(resolved.groupIds)
+  };
+}
+async function resolvePrincipalContext(ctx, actorId) {
+  if (actorId.startsWith("agent:")) {
+    const resolvers = resolveAccessControlAppResolvers();
+    const resolvedAgent = await resolvers.getAgentByPrincipalId(ctx, actorId);
+    if (resolvedAgent) {
+      const agent = requireCanonicalResolvedAgent(
+        resolvedAgent,
+        actorId
+      );
+      return {
+        principalId: agent.principalId,
+        principalType: "service",
+        clerkId: actorId,
+        tenantId: agent.tenantId,
+        workspaceId: agent.workspaceId,
+        roles: agent.roles.length > 0 ? agent.roles : ["service_agent"],
+        groupIds: agent.groupIds,
+        isPlatformAdmin: false,
+        isTenantAdmin: false,
+        isWorkspaceAdmin: false,
+        isSystemFallback: false
+      };
+    }
+    const resolvedUser2 = await resolvers.getUserByClerkId(
+      ctx,
+      actorId
+    );
+    if (!resolvedUser2) {
+      throw new Error(
+        `[AccessControl] Agent "${actorId}" not found in agents or users table.`
+      );
+    }
+    const user2 = requireServiceAgentUser(
+      resolvedUser2,
+      actorId
+    );
+    console.warn(
+      `[AccessControl] Deprecated legacy service-agent fallback for ${actorId}; migrate this principal into identity.agents.`
+    );
+    return {
+      principalId: user2.defaultPrincipalId,
+      principalType: "service",
+      clerkId: actorId,
+      tenantId: user2.defaultTenantId,
+      workspaceId: user2.defaultWorkspaceId,
+      roles: ["service_agent"],
+      groupIds: normalizeGroupIds(resolvedUser2?.principalGroupIds),
+      isPlatformAdmin: false,
+      isTenantAdmin: false,
+      isWorkspaceAdmin: false,
+      isSystemFallback: false
+    };
+  }
+  const {
+    resolvedUser,
+    contextClerkId
+  } = await resolveCanonicalUserRecord(ctx, actorId);
+  const user = requireCanonicalResolvedUser(
+    resolvedUser,
+    contextClerkId
+  );
+  if (!user.defaultPrincipalId) {
+    throw new Error(
+      `[AccessControl] Canonical federated principal required for ${contextClerkId}. Re-sync Master Control identity before user-bound access checks.`
+    );
+  }
+  if (user.mcRole === "service_agent") {
+    return {
+      principalId: user.defaultPrincipalId,
+      principalType: "service",
+      clerkId: contextClerkId,
+      tenantId: user.defaultTenantId,
+      workspaceId: user.defaultWorkspaceId,
+      roles: ["service_agent"],
+      groupIds: normalizeGroupIds(resolvedUser?.principalGroupIds),
+      isPlatformAdmin: false,
+      isTenantAdmin: false,
+      isWorkspaceAdmin: false,
+      isSystemFallback: false
+    };
+  }
+  const principalId = user.defaultPrincipalId;
+  const effectiveRole = user.mcRole;
+  const roles = effectiveRole === "platform_admin" ? ["platform_admin", "tenant_admin"] : effectiveRole === "tenant_admin" ? ["tenant_admin"] : [effectiveRole];
+  const tenantId = user.defaultTenantId;
+  const workspaceId = user.defaultWorkspaceId;
+  const isPlatformAdmin = effectiveRole === "platform_admin";
+  return {
+    principalId,
+    principalType: "user",
+    clerkId: contextClerkId,
+    tenantId,
+    workspaceId,
+    roles: uniqRoles(roles),
+    groupIds: normalizeGroupIds(resolvedUser?.principalGroupIds),
+    isPlatformAdmin,
+    isTenantAdmin: isPlatformAdmin || effectiveRole === "tenant_admin",
+    isWorkspaceAdmin: isPlatformAdmin || effectiveRole === "tenant_admin" || effectiveRole === "workspace_admin",
+    isSystemFallback: false
+  };
+}
+
+// ../access-control/src/access.ts
+function isTopicInPrincipalTenant(topic, principalTenantId) {
+  if (!topic.tenantId) {
+    return false;
+  }
+  if (!principalTenantId) {
+    return false;
+  }
+  return String(topic.tenantId) === String(principalTenantId);
+}
+function isTopicInPrincipalWorkspace(topic, principalWorkspaceId) {
+  if (!topic.workspaceId) {
+    return false;
+  }
+  if (!principalWorkspaceId) {
+    return false;
+  }
+  return String(topic.workspaceId) === String(principalWorkspaceId);
+}
+function isLegacyUnscopedTopic(topic) {
+  return !topic.tenantId || !topic.workspaceId;
+}
+function isGrantScopeAlignedToTopic(topic, grant) {
+  if (topic.tenantId && grant.tenantId && String(topic.tenantId) !== String(grant.tenantId)) {
+    return false;
+  }
+  if (topic.workspaceId && grant.workspaceId && String(topic.workspaceId) !== String(grant.workspaceId)) {
+    return false;
+  }
+  return true;
+}
+function isGrantSourceAllowedForVisibility(visibility, source) {
+  if (source !== "external_share") {
+    return true;
+  }
+  return visibility === "external" || visibility === "public";
+}
+function isGrantActive(grant) {
+  if (grant.status !== "active") {
+    return false;
+  }
+  if (grant.expiresAt !== void 0 && grant.expiresAt <= Date.now()) {
+    return false;
+  }
+  return true;
+}
+function isExternalPrincipal(_ctx, _args) {
+  return false;
+}
+async function getAccessibleTopicIds(ctx, userId) {
+  const principalContext = await resolvePrincipalContext(ctx, userId);
+  if (principalContext.isPlatformAdmin) {
+    const allTopics2 = await resolveAccessControlAppResolvers().listTopics(ctx);
+    return new Set(allTopics2.map((topic) => topic._id));
+  }
+  const topicIds = /* @__PURE__ */ new Set();
+  const ownedTopics = await resolveAccessControlAppResolvers().listTopicsByOwner(ctx, userId);
+  for (const topic of ownedTopics) {
+    topicIds.add(topic._id);
+  }
+  const publicTopics = await resolveAccessControlAppResolvers().listTopicsByVisibility(ctx, "public");
+  for (const topic of publicTopics) {
+    topicIds.add(topic._id);
+  }
+  const principalIsExternal = await isExternalPrincipal(ctx, {
+    groupIds: principalContext.groupIds,
+    topicTenantId: principalContext.tenantId ?? void 0,
+    topicWorkspaceId: principalContext.workspaceId ?? void 0
+  });
+  if (!principalIsExternal) {
+    const firmTopics = await resolveAccessControlAppResolvers().listTopicsByVisibility(ctx, "firm");
+    for (const topic of firmTopics) {
+      if (isTopicInPrincipalTenant(topic, principalContext.tenantId) && isTopicInPrincipalWorkspace(topic, principalContext.workspaceId)) {
+        topicIds.add(topic._id);
+      }
+    }
+  }
+  const directGrants = await resolveAccessControlAppResolvers().listProjectGrantsByPrincipalStatus(
+    ctx,
+    principalContext.principalId,
+    "active"
+  );
+  for (const grant of directGrants) {
+    if (!isGrantActive(grant)) {
+      continue;
+    }
+    const topic = await resolveAccessControlAppResolvers().getProject(
+      ctx,
+      grant.projectId
+    );
+    if (!topic) {
+      continue;
+    }
+    if (!isLegacyUnscopedTopic(topic)) {
+      if (!isTopicInPrincipalTenant(topic, principalContext.tenantId)) {
+        continue;
+      }
+      if (!isTopicInPrincipalWorkspace(topic, principalContext.workspaceId)) {
+        continue;
+      }
+    }
+    if (!isGrantScopeAlignedToTopic(topic, grant)) {
+      continue;
+    }
+    if (!isGrantSourceAllowedForVisibility(topic.visibility, grant.source)) {
+      continue;
+    }
+    if (principalIsExternal && topic.visibility !== "public" && grant.source !== "external_share") {
+      continue;
+    }
+    topicIds.add(grant.projectId);
+  }
+  const allTopics = await resolveAccessControlAppResolvers().listTopics(ctx);
+  for (const topic of allTopics) {
+    if ((topic.sharedWith ?? []).includes(userId) && (isLegacyUnscopedTopic(topic) || isTopicInPrincipalTenant(topic, principalContext.tenantId) && isTopicInPrincipalWorkspace(topic, principalContext.workspaceId))) {
+      topicIds.add(topic._id);
+    }
+  }
+  return topicIds;
+}
+var getAccessibleProjectIds = getAccessibleTopicIds;
+var permissiveReturn = v.optional(v.any());
+var looseJsonObject = v.record(v.string(), v.any());
+var looseJsonArray = v.array(v.any());
+v.union(
+  v.string(),
+  v.number(),
+  v.boolean(),
+  v.null(),
+  looseJsonObject,
+  looseJsonArray
+);
+var api2 = anyApi;
+componentsGeneric();
+var query = queryGeneric;
+
+// src/topicProjectOverlay.ts
+var LEGACY_SCOPE_FIELD2 = "graphScopeProjectId";
+function readNonEmptyString2(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function readStringArray2(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => readNonEmptyString2(entry)).filter((entry) => Boolean(entry));
+}
+function readMetadata2(topic) {
+  return topic.metadata && typeof topic.metadata === "object" ? topic.metadata : {};
+}
+function readLegacyProjectId2(value) {
+  if (!value) {
+    return;
+  }
+  return readNonEmptyString2(value[LEGACY_SCOPE_FIELD2]);
+}
+function coerceVisibility2(value) {
+  return value === "private" || value === "team" || value === "firm" || value === "external" || value === "public" ? value : void 0;
+}
+function coerceStatus2(value) {
+  return value === "active" || value === "archived" || value === "watching" ? value : void 0;
+}
+function mapProjectType2(topic, metadata) {
+  const explicit = readNonEmptyString2(metadata.projectType);
+  if (explicit) {
+    return explicit;
+  }
+  if (topic.type === "theme") {
+    return "thematic";
+  }
+  return readNonEmptyString2(topic.type) || "general";
+}
+function isProjectLikeTopic2(topic) {
+  const metadata = readMetadata2(topic);
+  return topic.type === "theme" || topic.type === "thematic" || topic.type === "deal" || topic.type === "monitoring" || readLegacyProjectId2(topic) !== void 0 || readNonEmptyString2(metadata.projectType) !== void 0;
+}
+function isMissingLucernChildComponentError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes(
+    'Child component ComponentName(Identifier("lucern")) not found'
+  ) || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
+}
+async function resolveTopicDoc2(ctx, scopeId) {
+  if (ctx?.db && typeof ctx.db.get === "function") {
+    try {
+      const directTopic = await ctx.db.get(scopeId);
+      if (directTopic) {
+        return directTopic;
+      }
+    } catch {
+    }
+  }
+  if (typeof ctx.runQuery !== "function") {
+    return null;
+  }
+  try {
+    const topic = await ctx.runQuery(api2.topics.get, {
+      id: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch {
+  }
+  try {
+    const topic = await ctx.runQuery(api2.topics.getByLegacyScopeId, {
+      projectId: String(scopeId)
+    });
+    if (topic?.name !== void 0 && topic?.type !== void 0) {
+      return topic;
+    }
+  } catch {
+  }
+  return null;
+}
+function materializeTopicProjectOverlay2(topic, idMode = "legacy") {
+  const metadata = readMetadata2(topic);
+  const topicId = String(topic._id);
+  const legacyProjectId = readLegacyProjectId2(topic) || readLegacyProjectId2(metadata) || readNonEmptyString2(metadata.legacyProjectId);
+  const storageProjectId = legacyProjectId || topicId;
+  const outwardId = idMode === "topic" ? topicId : storageProjectId;
+  const visibility = coerceVisibility2(topic.visibility) || coerceVisibility2(metadata.visibility) || "private";
+  const status = coerceStatus2(topic.status) || coerceStatus2(metadata.status) || "active";
+  const createdAt = typeof topic.createdAt === "number" ? topic.createdAt : typeof topic._creationTime === "number" ? topic._creationTime : 0;
+  const updatedAt = typeof topic.updatedAt === "number" ? topic.updatedAt : typeof metadata.updatedAt === "number" ? metadata.updatedAt : createdAt;
+  return {
+    ...metadata,
+    _id: outwardId,
+    projectId: outwardId,
+    topicId,
+    storageProjectId,
+    legacyProjectId,
+    name: readNonEmptyString2(topic.name) || "Untitled Theme",
+    type: mapProjectType2(topic, metadata),
+    description: readNonEmptyString2(topic.description),
+    ownerId: readNonEmptyString2(metadata.ownerId) || readNonEmptyString2(topic.createdBy) || "system",
+    sharedWith: readStringArray2(metadata.sharedWith),
+    visibility,
+    tenantId: readNonEmptyString2(topic.tenantId) || readNonEmptyString2(metadata.tenantId),
+    workspaceId: readNonEmptyString2(topic.workspaceId) || readNonEmptyString2(metadata.workspaceId),
+    status,
+    tags: readStringArray2(metadata.tags),
+    chatCount: typeof metadata.chatCount === "number" ? metadata.chatCount : 0,
+    artifactCount: typeof metadata.artifactCount === "number" ? metadata.artifactCount : 0,
+    lastActivityAt: typeof metadata.lastActivityAt === "number" ? metadata.lastActivityAt : updatedAt,
+    _creationTime: typeof topic._creationTime === "number" ? topic._creationTime : createdAt,
+    createdAt,
+    updatedAt
+  };
+}
+async function resolveTopicProjectOverlay2(ctx, scopeId, options = {}) {
+  const topic = await resolveTopicDoc2(ctx, scopeId);
+  if (!topic) {
+    return null;
+  }
+  if (options.projectLikeOnly !== false && !isProjectLikeTopic2(topic)) {
+    return null;
+  }
+  return materializeTopicProjectOverlay2(topic, options.idMode);
+}
+async function listTopicProjectOverlays2(ctx, options = {}) {
+  let allTopics = [];
+  if (ctx?.db?.query && typeof ctx.db.query === "function") {
+    try {
+      allTopics = await ctx.db.query("topics").collect();
+    } catch {
+      allTopics = [];
+    }
+  }
+  if (allTopics.length === 0 && typeof ctx.runQuery === "function") {
+    allTopics = (await ctx.runQuery(api2.topics.list, {}) ?? []) || [];
+  }
+  return allTopics.filter(
+    (topic) => options.projectLikeOnly === false || isProjectLikeTopic2(topic)
+  ).map((topic) => materializeTopicProjectOverlay2(topic, options.idMode));
+}
+async function patchTopicProjectOverlay(ctx, scopeId, value) {
+  const topic = await resolveTopicDoc2(ctx, scopeId);
+  if (!topic) {
+    return null;
+  }
+  const nextMetadata = { ...readMetadata2(topic) };
+  const patch = {};
+  const topicUpdateArgs = {
+    id: String(topic._id)
+  };
+  for (const [key, rawValue] of Object.entries(value)) {
+    switch (key) {
+      case "_id":
+      case "projectId":
+      case "topicId":
+      case "legacyProjectId":
+      case "storageProjectId":
+        break;
+      case "name":
+      case "description":
+        patch[key] = rawValue;
+        topicUpdateArgs[key] = rawValue;
+        break;
+      case "tenantId":
+      case "workspaceId":
+      case "ownerId":
+        throw new Error(
+          `patchTopicProjectOverlay cannot mutate ${key} via component-owned topics`
+        );
+      case "status": {
+        const status = coerceStatus2(rawValue);
+        if (status) {
+          patch.status = status;
+          topicUpdateArgs.status = status;
+        }
+        break;
+      }
+      case "visibility": {
+        const visibility = coerceVisibility2(rawValue);
+        if (visibility) {
+          patch.visibility = visibility;
+          topicUpdateArgs.visibility = visibility;
+        }
+        break;
+      }
+      case "type": {
+        const projectType = readNonEmptyString2(rawValue);
+        if (projectType) {
+          nextMetadata.projectType = projectType;
+        } else {
+          delete nextMetadata.projectType;
+        }
+        break;
+      }
+      case "updatedAt":
+      case "createdAt":
+        break;
+      default:
+        if (rawValue === void 0) {
+          delete nextMetadata[key];
+        } else {
+          nextMetadata[key] = rawValue;
+        }
+    }
+  }
+  patch.updatedAt = Date.now();
+  patch.metadata = nextMetadata;
+  topicUpdateArgs.metadata = nextMetadata;
+  if (typeof ctx.runMutation === "function") {
+    try {
+      await ctx.runMutation(api2.topics.update, topicUpdateArgs);
+    } catch (error) {
+      if (!isMissingLucernChildComponentError(error) || !ctx?.db || typeof ctx.db.patch !== "function") {
+        throw error;
+      }
+      await ctx.db.patch(String(topic._id), patch);
+    }
+  } else if (ctx?.db && typeof ctx.db.patch === "function") {
+    await ctx.db.patch(String(topic._id), patch);
+  } else {
+    throw new Error(
+      "Cannot patch topic without component adapter (ctx.runMutation unavailable)"
+    );
+  }
+  return materializeTopicProjectOverlay2(
+    {
+      ...topic,
+      ...patch,
+      metadata: nextMetadata
+    }
+  );
+}
+
+// src/resolvers.ts
+function isMissingLucernChildComponentError2(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes('Child component ComponentName(Identifier("lucern")) not found') || message.includes("Child component") && message.includes("lucern") && message.includes("not found");
+}
+function isAdvisoryTopicPatch(value) {
+  const advisoryKeys = /* @__PURE__ */ new Set(["lastActivityAt", "updatedAt"]);
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((key) => advisoryKeys.has(key));
+}
+async function patchProjectWithTolerance(ctx, projectId, value) {
+  try {
+    await patchTopicProjectOverlay(ctx, projectId, value);
+  } catch (error) {
+    if (!isAdvisoryTopicPatch(value) || !isMissingLucernChildComponentError2(error)) {
+      throw error;
+    }
+    console.warn("[lucern graph-primitives] Non-fatal advisory topic patch failure", {
+      projectId,
+      keys: Object.keys(value),
+      error: error instanceof Error ? error.message : error
+    });
+  }
+}
+function defaultResolvers2() {
+  return {
+    async getProject(ctx, projectId) {
+      return await resolveTopicProjectOverlay2(ctx, projectId, {
+        idMode: "legacy",
+        projectLikeOnly: false
+      });
+    },
+    async patchProject(ctx, projectId, value) {
+      await patchProjectWithTolerance(ctx, projectId, value);
+    },
+    async listTopics(ctx) {
+      return await listTopicProjectOverlays2(ctx, {
+        idMode: "legacy"
+      });
+    },
+    async getFinalArtifact(ctx, artifactId) {
+      return await ctx.db.get(artifactId);
+    }
+  };
+}
+var resolverOverrides2 = {};
+function resolveGraphPrimitivesAppResolvers(_ctx) {
+  return {
+    ...defaultResolvers2(),
+    ...resolverOverrides2
+  };
+}
+var optionalScopeArgs = {
+  projectId: v.optional(v.string()),
+  topicId: v.optional(v.string())
+};
+
+// src/beliefDecay.ts
+var identifyBeliefsNeedingRescore = query({
+  args: {
+    ...optionalScopeArgs,
+    maxResults: v.optional(v.number()),
+    // Only return beliefs at or above this priority
+    minPriority: v.optional(
+      v.union(
+        v.literal("critical"),
+        v.literal("high"),
+        v.literal("medium"),
+        v.literal("low")
+      )
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const { projectId, maxResults = 20, minPriority = "medium" } = args;
+    const priorityRank = {
+      critical: 4,
+      high: 3,
+      medium: 2,
+      low: 1
+    };
+    const minRank = priorityRank[minPriority] ?? 2;
+    const beliefs = await ctx.db.query("epistemicNodes").withIndex(
+      args.topicId ? "by_topic_type" : "by_project_type",
+      (q) => args.topicId ? q.eq("topicId", args.topicId).eq("nodeType", "belief") : q.eq("projectId", projectId).eq("nodeType", "belief")
+    ).collect();
+    const activeBeliefs = beliefs.filter((b) => b.status === "active");
+    const results = [];
+    for (const belief of activeBeliefs) {
+      const metadata = belief.metadata || {};
+      const predictionMeta = belief.predictionMeta;
+      const temporalNature = belief.temporalNature || "unknown";
+      const beliefStatus = belief.beliefStatus || metadata.beliefStatus || null;
+      const confidenceHistory = await ctx.db.query("beliefConfidence").withIndex("by_beliefId", (q) => q.eq("beliefId", belief._id)).collect();
+      const sorted = confidenceHistory.sort(
+        (a, b) => b.assessedAt - a.assessedAt
+      );
+      const lastEntry = sorted[0] ?? null;
+      const lastScoredAt = lastEntry?.assessedAt || belief.updatedAt || belief.createdAt || Date.now();
+      const confidence = lastEntry?.confidence ?? metadata.confidence ?? 0.5;
+      const schedule = getRescoringSchedule({
+        lastScoredAt,
+        temporalNature,
+        expectedBy: predictionMeta?.expectedBy ?? null,
+        predictionMeta: predictionMeta ?? null,
+        confidence,
+        beliefStatus
+      });
+      if (priorityRank[schedule.priority] >= minRank) {
+        results.push({
+          beliefId: belief._id,
+          beliefText: belief.canonicalText,
+          confidence,
+          beliefStatus: beliefStatus ?? "assumption",
+          temporalNature,
+          expectedBy: predictionMeta?.expectedBy ?? null,
+          lastScoredAt,
+          daysSinceScoring: Math.round(schedule.decay.ageDays),
+          schedule
+        });
+      }
+    }
+    results.sort((a, b) => {
+      const rankDiff = priorityRank[b.schedule.priority] - priorityRank[a.schedule.priority];
+      if (rankDiff !== 0) {
+        return rankDiff;
+      }
+      return a.schedule.daysUntilRescore - b.schedule.daysUntilRescore;
+    });
+    return {
+      beliefs: results.slice(0, maxResults),
+      summary: {
+        total: results.length,
+        critical: results.filter((r) => r.schedule.priority === "critical").length,
+        high: results.filter((r) => r.schedule.priority === "high").length,
+        medium: results.filter((r) => r.schedule.priority === "medium").length,
+        overdue: results.filter((r) => r.schedule.isOverdue).length,
+        forecastsApproaching: results.filter(
+          (r) => r.temporalNature === "forecast" && r.schedule.decay.urgency?.urgencyTier.label !== "distant"
+        ).length
+      }
+    };
+  }
+});
+var getGlobalBeliefHealth = query({
+  args: {
+    clerkId: v.string(),
+    maxResults: v.optional(v.number()),
+    minPriority: v.optional(
+      v.union(
+        v.literal("critical"),
+        v.literal("high"),
+        v.literal("medium"),
+        v.literal("low")
+      )
+    )
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const { clerkId, maxResults = 30, minPriority = "medium" } = args;
+    const priorityRank = {
+      critical: 4,
+      high: 3,
+      medium: 2,
+      low: 1
+    };
+    const minRank = priorityRank[minPriority] ?? 2;
+    const allProjects = await resolveGraphPrimitivesAppResolvers().listTopics(ctx);
+    const accessibleProjectIds = await getAccessibleProjectIds(ctx, clerkId);
+    const accessibleProjects = allProjects.filter(
+      (project2) => accessibleProjectIds.has(project2._id)
+    );
+    const allResults = [];
+    for (const project2 of accessibleProjects.slice(0, 20)) {
+      const [topicBeliefs, projectBeliefs] = await Promise.all([
+        ctx.db.query("epistemicNodes").withIndex(
+          "by_topic_type",
+          (q) => q.eq("topicId", project2._id).eq("nodeType", "belief")
+        ).collect(),
+        ctx.db.query("epistemicNodes").withIndex(
+          "by_project_type",
+          (q) => q.eq("projectId", project2._id).eq("nodeType", "belief")
+        ).collect()
+      ]);
+      const beliefs = Array.from(
+        new Map(
+          [...topicBeliefs, ...projectBeliefs].map((b) => [String(b._id), b])
+        ).values()
+      );
+      const activeBeliefs = beliefs.filter((b) => b.status === "active");
+      for (const belief of activeBeliefs) {
+        const metadata = belief.metadata || {};
+        const predictionMeta = belief.predictionMeta;
+        const temporalNature = belief.temporalNature || "unknown";
+        const confidence = belief.confidence ?? metadata.confidence ?? 0.5;
+        const lastScoredAt = belief.updatedAt || belief.createdAt || belief._creationTime;
+        const schedule = getRescoringSchedule({
+          lastScoredAt,
+          temporalNature,
+          expectedBy: predictionMeta?.expectedBy ?? null,
+          predictionMeta: predictionMeta ?? null,
+          confidence,
+          beliefStatus: belief.beliefStatus || metadata.beliefStatus || null
+        });
+        if (priorityRank[schedule.priority] >= minRank) {
+          allResults.push({
+            projectId: project2._id,
+            projectName: project2.name,
+            beliefId: belief._id,
+            beliefText: belief.canonicalText,
+            confidence,
+            temporalNature,
+            expectedBy: predictionMeta?.expectedBy ?? null,
+            daysSinceScoring: Math.round(schedule.decay.ageDays),
+            priority: schedule.priority,
+            reason: schedule.reason,
+            deadlineUrgency: schedule.decay.urgency?.urgencyTier.label ?? null
+          });
+        }
+      }
+    }
+    allResults.sort((a, b) => {
+      const rankDiff = priorityRank[b.priority] - priorityRank[a.priority];
+      if (rankDiff !== 0) {
+        return rankDiff;
+      }
+      return b.daysSinceScoring - a.daysSinceScoring;
+    });
+    const results = allResults.slice(0, maxResults);
+    const projectGroups = /* @__PURE__ */ new Map();
+    for (const r of allResults) {
+      projectGroups.set(
+        r.projectName,
+        (projectGroups.get(r.projectName) || 0) + 1
+      );
+    }
+    return {
+      beliefs: results,
+      summary: {
+        total: allResults.length,
+        critical: allResults.filter((r) => r.priority === "critical").length,
+        high: allResults.filter((r) => r.priority === "high").length,
+        medium: allResults.filter((r) => r.priority === "medium").length,
+        projectsAffected: projectGroups.size,
+        forecastsApproaching: allResults.filter(
+          (r) => r.temporalNature === "forecast" && r.deadlineUrgency && r.deadlineUrgency !== "distant"
+        ).length,
+        byProject: Array.from(projectGroups.entries()).map(([name, count]) => ({
+          projectName: name,
+          count
+        }))
+      }
+    };
+  }
+});
+var getBeliefDecayInfo = query({
+  args: {
+    beliefId: v.id("epistemicNodes")
+  },
+  returns: permissiveReturn,
+  handler: async (ctx, args) => {
+    const belief = await ctx.db.get(args.beliefId);
+    if (!belief) {
+      return null;
+    }
+    const metadata = belief.metadata || {};
+    const predictionMeta = belief.predictionMeta;
+    const temporalNature = belief.temporalNature || "unknown";
+    const confidenceHistory = await ctx.db.query("beliefConfidence").withIndex("by_beliefId", (q) => q.eq("beliefId", args.beliefId)).collect();
+    const sorted = confidenceHistory.sort(
+      (a, b) => b.assessedAt - a.assessedAt
+    );
+    const lastEntry = sorted[0] ?? null;
+    const lastScoredAt = lastEntry?.assessedAt || belief.updatedAt || belief.createdAt || Date.now();
+    const confidence = lastEntry?.confidence ?? metadata.confidence ?? 0.5;
+    const schedule = getRescoringSchedule({
+      lastScoredAt,
+      temporalNature,
+      expectedBy: predictionMeta?.expectedBy ?? null,
+      predictionMeta: predictionMeta ?? null,
+      confidence,
+      beliefStatus: belief.beliefStatus || metadata.beliefStatus || null
+    });
+    const decay = schedule.decay;
+    return {
+      confidence,
+      decayedConfidence: confidence * decay.effectiveWeight,
+      freshness: {
+        label: decay.baseTier.label,
+        ageDays: Math.round(decay.ageDays),
+        weight: decay.effectiveWeight,
+        action: decay.action
+      },
+      deadline: decay.urgency ? {
+        daysToDeadline: decay.urgency.daysToDeadline,
+        urgency: decay.urgency.urgencyTier.label,
+        isOverdue: decay.urgency.isOverdue
+      } : null,
+      rescoringSchedule: {
+        nextRescoreBy: schedule.nextRescoreBy,
+        daysUntilRescore: schedule.daysUntilRescore,
+        isOverdue: schedule.isOverdue,
+        priority: schedule.priority,
+        reason: schedule.reason
+      }
+    };
+  }
+});
+
+export { DEADLINE_URGENCY, DECAY_TIERS, bayesianUpdate, computeBaseDecay, computeDeadlineUrgency, computeEffectiveDecay, getBeliefDecayInfo, getGlobalBeliefHealth, getRescoringSchedule, identifyBeliefsNeedingRescore };
+//# sourceMappingURL=beliefDecay.js.map
+//# sourceMappingURL=beliefDecay.js.map