@vibgrate/cli 2026.801.1 → 2026.803.3

package/dist/{chunk-SDG242R4.js → chunk-HC44772H.js}

@@ -1,4 +1,4 @@
-import { cacheDir } from './chunk-ZKNB4YH4.js';
+import { cacheDir, bigramConsumedTokens, WEAK_TERMS, expandConcepts } from './chunk-QMME6TB4.js';
 import { hashString } from './chunk-JFGYT6BI.js';
 import * as fs2 from 'fs';
 import { createRequire } from 'module';
@@ -436,350 +436,6 @@ function safe(id) {
   return id.replace(/[^a-z0-9.-]+/gi, "_");
 }
 
-// src/engine/concepts.ts
-var WEAK_TERMS = /* @__PURE__ */ new Set([
-  "add",
-  "adds",
-  "added",
-  "adding",
-  "create",
-  "creates",
-  "created",
-  "creating",
-  "make",
-  "makes",
-  "making",
-  "made",
-  "new",
-  "newly",
-  "remove",
-  "removes",
-  "removed",
-  "removing",
-  "delete",
-  "deletes",
-  "deleted",
-  "deleting",
-  "update",
-  "updates",
-  "updated",
-  "updating",
-  "change",
-  "changes",
-  "changed",
-  "changing",
-  "set",
-  "sets",
-  "setting",
-  "setup",
-  "get",
-  "gets",
-  "getting",
-  "use",
-  "uses",
-  "used",
-  "using",
-  "want",
-  "wants",
-  "wanted",
-  "do",
-  "does",
-  "doing",
-  "done",
-  "support",
-  "supports",
-  "supported",
-  "supporting",
-  "enable",
-  "enables",
-  "enabled",
-  "enabling",
-  "disable",
-  "disables",
-  "disabled",
-  "disabling",
-  "allow",
-  "allows",
-  "allowed",
-  "implement",
-  "implements",
-  "implemented",
-  "implementing",
-  "build",
-  "builds",
-  "building",
-  "built",
-  "via",
-  "through",
-  "into",
-  "onto",
-  "way",
-  "ways",
-  "thing",
-  "things",
-  "stuff",
-  "feature",
-  "features",
-  "functionality",
-  "method",
-  "methods",
-  "option",
-  "options",
-  "ability",
-  "help",
-  "start",
-  "begin",
-  "work",
-  "works",
-  "working",
-  "also",
-  "currently",
-  "properly",
-  "correctly",
-  "please",
-  "happens",
-  "happen",
-  "something",
-  "somewhere",
-  "step",
-  "steps",
-  "flow",
-  "process",
-  "you",
-  "can"
-]);
-var CONCEPTS = {
-  // ---- payments / billing ----
-  payment: ["stripe", "billing", "invoice", "checkout", "charge", "subscription", "refund", "payout", "card", "debit", "mandate"],
-  pay: ["payment", "stripe", "charge", "billing", "invoice"],
-  paid: ["payment", "invoice", "charge"],
-  billing: ["invoice", "payment", "subscription", "stripe", "charge", "renewal"],
-  checkout: ["stripe", "payment", "cart", "session"],
-  debit: ["mandate", "sepa", "bacs", "ach", "bank", "payment"],
-  mandate: ["sepa", "bacs", "debit"],
-  sepa: ["mandate", "debit", "iban", "bank"],
-  bacs: ["mandate", "debit", "bank"],
-  ach: ["mandate", "debit", "bank"],
-  stripe: ["payment", "billing", "checkout", "webhook", "charge", "card"],
-  refund: ["payment", "invoice", "stripe", "charge"],
-  invoice: ["billing", "payment", "refund", "subscription"],
-  subscription: ["billing", "renewal", "invoice", "plan", "recurring"],
-  recurring: ["subscription", "renewal", "mandate", "debit"],
-  renewal: ["subscription", "billing", "renew"],
-  card: ["payment", "charge", "stripe"],
-  credit: ["card", "payment", "charge"],
-  bank: ["debit", "mandate", "sepa", "iban", "account"],
-  charge: ["payment", "card", "stripe"],
-  webhook: ["event", "handler", "callback"],
-  price: ["payment", "billing", "plan"],
-  customer: ["billing", "account", "user"],
-  // ---- auth ----
-  auth: ["login", "session", "token", "oauth", "password", "credential"],
-  authentication: ["auth", "login", "session", "token", "password"],
-  authenticated: ["auth", "login", "session"],
-  login: ["auth", "session", "password", "signin", "oauth"],
-  signin: ["login", "auth", "session"],
-  signup: ["register", "onboard", "account"],
-  logout: ["session", "auth", "signout"],
-  password: ["auth", "login", "credential", "hash"],
-  session: ["auth", "login", "token"],
-  token: ["session", "auth", "jwt"],
-  oauth: ["auth", "login", "callback", "provider"],
-  google: ["oauth", "login", "auth"],
-  github: ["oauth", "login", "auth"],
-  sso: ["oauth", "auth", "saml", "login"],
-  credential: ["auth", "password", "token", "secret"],
-  // ---- dependencies / supply chain ----
-  dependency: ["package", "audit", "vulnerability", "advisory", "lockfile", "version"],
-  package: ["dependency", "audit", "vulnerability", "advisory", "lockfile"],
-  vulnerability: ["advisory", "cve", "osv", "audit", "vulnerable"],
-  vulnerable: ["vulnerability", "advisory", "audit", "cve"],
-  advisory: ["vulnerability", "cve", "osv", "audit"],
-  cve: ["vulnerability", "advisory", "osv"],
-  risk: ["vulnerability", "audit", "advisory"],
-  security: ["vulnerability", "audit", "advisory"],
-  audit: ["dependency", "vulnerability", "advisory"],
-  scan: ["audit", "vulnerability", "scanner"],
-  // ---- notifications / messaging ----
-  email: ["mail", "smtp", "sender", "template", "message"],
-  mail: ["email", "smtp", "sender"],
-  notification: ["notify", "email", "sms", "push", "alert"],
-  notify: ["notification", "email", "alert"],
-  sms: ["notification", "message", "twilio"],
-  // ---- e-commerce ----
-  cart: ["checkout", "order", "shop", "basket", "discount"],
-  basket: ["cart", "checkout", "order"],
-  order: ["cart", "shipment", "fulfillment", "shop", "checkout"],
-  ship: ["order", "fulfillment", "delivery", "shipment"],
-  shipment: ["order", "fulfillment", "delivery", "track"],
-  shipping: ["order", "fulfillment", "delivery", "shipment"],
-  shipped: ["order", "fulfillment", "shipment"],
-  inventory: ["stock", "product", "catalog", "restock"],
-  stock: ["inventory", "product", "restock"],
-  product: ["catalog", "inventory", "shop"],
-  discount: ["coupon", "promo", "cart", "price"],
-  coupon: ["discount", "promo", "code"],
-  // ---- chat / social ----
-  chat: ["message", "room", "conversation", "presence"],
-  message: ["chat", "sms", "notification", "thread"],
-  conversation: ["chat", "message", "thread"],
-  presence: ["online", "typing", "status"],
-  online: ["presence", "status"],
-  typing: ["presence", "indicator", "broadcast"],
-  // ---- media / streaming ----
-  video: ["media", "transcode", "playback", "stream", "thumbnail"],
-  stream: ["video", "playback", "manifest", "media"],
-  streaming: ["video", "playback", "manifest", "media"],
-  playback: ["video", "stream", "media", "watch"],
-  transcode: ["video", "media", "encode"],
-  thumbnail: ["video", "image", "media"],
-  media: ["video", "stream", "playback", "asset"],
-  // ---- analytics ----
-  analytics: ["event", "track", "metric", "funnel", "report"],
-  event: ["track", "analytics", "webhook"],
-  track: ["event", "analytics"],
-  funnel: ["conversion", "analytics", "event"],
-  conversion: ["funnel", "analytics"],
-  report: ["metrics", "export", "analytics"],
-  // ---- content / CMS ----
-  article: ["publish", "content", "post", "cms"],
-  publish: ["article", "release", "post", "content"],
-  post: ["article", "publish", "message"],
-  blog: ["article", "publish", "post", "cms"],
-  content: ["cms", "article", "markdown"],
-  markdown: ["render", "article", "content"],
-  cms: ["article", "content", "publish"],
-  // ---- CI / deployment ----
-  deploy: ["release", "rollback", "pipeline", "deployment"],
-  deployment: ["deploy", "release", "rollback", "pipeline"],
-  release: ["deploy", "version", "rollback"],
-  rollback: ["deploy", "release", "deployment"],
-  pipeline: ["stage", "deploy", "runner", "ci"],
-  canary: ["deploy", "rollout", "release"],
-  // ---- mobile ----
-  push: ["notification", "device", "token", "mobile"],
-  device: ["push", "token", "mobile", "register"],
-  deeplink: ["link", "route", "universal"],
-  mobile: ["push", "device", "deeplink", "app"],
-  ios: ["mobile", "universal", "link", "app"],
-  android: ["mobile", "push", "device", "app"],
-  // ---- batch / ETL / mainframe ----
-  batch: ["settlement", "job", "etl", "reconcile"],
-  settlement: ["batch", "reconcile", "ledger", "clearing"],
-  reconcile: ["ledger", "settlement", "batch"],
-  ledger: ["settlement", "reconcile", "balance", "journal"],
-  mainframe: ["batch", "settlement", "ebcdic", "cobol", "fixed"],
-  ebcdic: ["mainframe", "record", "convert", "legacy"],
-  cobol: ["mainframe", "batch", "ebcdic"],
-  etl: ["batch", "pipeline", "extract", "load", "transform"],
-  nightly: ["batch", "cron", "schedule", "job"],
-  // ---- geo / maps ----
-  geocode: ["address", "location", "map", "geo"],
-  address: ["geocode", "location"],
-  map: ["geo", "route", "location"],
-  route: ["distance", "path", "planner", "geo"],
-  distance: ["route", "haversine", "geo"],
-  location: ["geo", "geocode", "map"],
-  arrival: ["route", "eta", "estimate"],
-  // ---- i18n ----
-  translation: ["locale", "i18n", "language", "translate"],
-  translate: ["translation", "locale", "language"],
-  locale: ["translation", "i18n", "language", "format"],
-  i18n: ["translation", "locale", "language"],
-  language: ["locale", "translation", "i18n"],
-  localized: ["locale", "translation", "format"],
-  // ---- observability ----
-  metric: ["counter", "prometheus", "telemetry", "export"],
-  prometheus: ["metric", "exporter", "monitoring"],
-  trace: ["span", "telemetry", "observability"],
-  span: ["trace", "telemetry"],
-  monitoring: ["metric", "trace", "alert", "observability"],
-  telemetry: ["metric", "trace", "span"],
-  counter: ["metric", "increment"],
-  // ---- feature flags / experimentation ----
-  flag: ["feature", "rollout", "toggle", "experiment"],
-  rollout: ["flag", "percentage", "release", "experiment"],
-  toggle: ["flag", "feature", "switch"],
-  experiment: ["variant", "assign", "flag", "exposure"],
-  variant: ["experiment", "assign"],
-  // ---- generic infrastructure ----
-  database: ["schema", "migration", "sql", "query", "orm"],
-  db: ["database", "schema", "migration", "sql"],
-  migration: ["database", "schema", "migrate", "sql"],
-  cache: ["redis", "ttl", "store"],
-  queue: ["job", "worker", "task", "batch"],
-  job: ["queue", "worker", "cron"],
-  upload: ["file", "storage", "blob", "asset"],
-  storage: ["file", "upload", "bucket", "blob"],
-  permission: ["role", "rbac", "acl", "access", "grant"],
-  role: ["permission", "rbac", "access"],
-  error: ["exception", "failure", "handler"],
-  config: ["settings", "env", "configuration"]
-};
-var BIGRAM_CONCEPTS = {
-  "direct debit": ["debit", "mandate", "sepa", "bacs", "bank"],
-  "direct debits": ["debit", "mandate", "sepa", "bacs", "bank"],
-  "sign in": ["login", "signin", "auth", "session"],
-  "signs in": ["login", "signin", "auth", "session"],
-  "log in": ["login", "auth", "session"],
-  "logs in": ["login", "auth", "session"],
-  "logged in": ["login", "auth", "session"],
-  "sign up": ["signup", "register", "account"],
-  "credit card": ["card", "payment", "charge", "stripe"],
-  "credit cards": ["card", "payment", "charge", "stripe"],
-  "bank transfer": ["bank", "payment", "sepa", "transfer"],
-  "rate limit": ["ratelimit", "throttle", "quota"],
-  "two factor": ["totp", "mfa", "otp", "auth"],
-  "payment method": ["payment", "stripe", "card", "debit"],
-  "payment methods": ["payment", "stripe", "card", "debit"],
-  "push notification": ["push", "device", "token", "notification"],
-  "push notifications": ["push", "device", "token", "notification"],
-  "deep link": ["deeplink", "link", "route"],
-  "deep links": ["deeplink", "link", "route"],
-  "universal link": ["deeplink", "link", "universal"],
-  "universal links": ["deeplink", "link", "universal"],
-  "feature flag": ["flag", "rollout", "toggle", "experiment"],
-  "feature flags": ["flag", "rollout", "toggle", "experiment"],
-  "shopping cart": ["cart", "checkout", "order"],
-  "roll back": ["rollback", "deploy", "release"],
-  "rolled back": ["rollback", "deploy", "release"],
-  "ab test": ["experiment", "variant"],
-  "sign out": ["logout", "session", "auth"],
-  "fixed width": ["record", "export", "mainframe", "batch"]
-};
-function lexiconKey(token) {
-  if (token in CONCEPTS) return token;
-  if (token.endsWith("ies")) {
-    const singular = token.slice(0, -3) + "y";
-    if (singular in CONCEPTS) return singular;
-  }
-  if (token.endsWith("s")) {
-    const singular = token.slice(0, -1);
-    if (singular in CONCEPTS) return singular;
-  }
-  return null;
-}
-function expandConcepts(orderedTokens) {
-  const present = new Set(orderedTokens);
-  const out = [];
-  const emitted = /* @__PURE__ */ new Set();
-  const emit = (term, from) => {
-    if (present.has(term) || emitted.has(term)) return;
-    emitted.add(term);
-    out.push({ term, from });
-  };
-  for (let i = 0; i + 1 < orderedTokens.length; i++) {
-    const bigram = `${orderedTokens[i]} ${orderedTokens[i + 1]}`;
-    const terms = BIGRAM_CONCEPTS[bigram];
-    if (terms) for (const t of terms) emit(t, bigram);
-  }
-  for (const token of orderedTokens) {
-    const key = lexiconKey(token);
-    if (key) for (const t of CONCEPTS[key]) emit(t, token);
-  }
-  return out;
-}
-
 // src/engine/query.ts
 var STOPWORDS = /* @__PURE__ */ new Set([
   "the",
@@ -931,7 +587,7 @@ function queryGraph(graph, question, options = {}) {
   const limit = options.limit ?? 12;
   const literals = extractLiteralNeedles(question);
   const forTokens = literals.length > 0 ? stripLiteralNeedles(question) : question;
-  const prep = prepareTerms(forTokens);
+  const prep = prepareTerms(forTokens, options.relevance, priorResidual(options.priorQuestion));
   const weightOf = termWeights(graph, prep.terms.map((t) => t.term));
   const index = indexFor(graph);
   const scored = [];
@@ -939,7 +595,14 @@ function queryGraph(graph, question, options = {}) {
     for (const node of graph.nodes) {
       if (node.kind === "file" || node.kind === "external") continue;
       const { score, why } = scoreNode(node, prep.terms, weightOf);
-      if (score > 0) scored.push({ node, score: round(score * (1 + IMPORTANCE_WEIGHT * node.importance)), why });
+      if (score > 0) {
+        const affinity = topicAffinity(node.id, options.relevance, options.topicTags);
+        scored.push({
+          node,
+          score: round(score * affinity.boost * (1 + IMPORTANCE_WEIGHT * node.importance)),
+          why: why + affinity.label
+        });
+      }
     }
     scored.sort((a, b) => b.score - a.score || a.node.qualifiedName.localeCompare(b.node.qualifiedName));
   }
@@ -947,18 +610,22 @@ function queryGraph(graph, question, options = {}) {
   const { context, tokensEstimate } = buildContext(graph, index, question, seeds, budget, literals);
   return { question, matches: seeds, context, tokensEstimate };
 }
+var RRF_K = 60;
+function ranksOf(scores, nameOf) {
+  const ids = [...scores.entries()].filter(([, s]) => s > 0).sort((a, b) => b[1] - a[1] || nameOf(a[0]).localeCompare(nameOf(b[0]))).map(([id]) => id);
+  return new Map(ids.map((id, i) => [id, i + 1]));
+}
 async function queryGraphSemantic(graph, question, options) {
   const budget = options.budget ?? 2e3;
   const limit = options.limit ?? 12;
   const literals = extractLiteralNeedles(question);
   const forTokens = literals.length > 0 ? stripLiteralNeedles(question) : question;
-  const prep = prepareTerms(forTokens);
+  const prep = prepareTerms(forTokens, options.relevance, priorResidual(options.priorQuestion));
   const terms = prep.terms.map((t) => t.term);
   const weightOf = termWeights(graph, terms);
   const index = indexFor(graph);
   const queryVec = await options.embedder.embedQuery(forTokens || question);
   const lexRaw = /* @__PURE__ */ new Map();
-  let lexMax = 0;
   const whyById = /* @__PURE__ */ new Map();
   if (prep.hasContent) {
     for (const node of graph.nodes) {
@@ -966,21 +633,32 @@ async function queryGraphSemantic(graph, question, options) {
       const { score, why } = scoreNode(node, prep.terms, weightOf);
       lexRaw.set(node.id, score);
       whyById.set(node.id, why);
-      if (score > lexMax) lexMax = score;
     }
   }
   const scored = [];
   if (terms.length > 0 || literals.length === 0) {
+    const semRaw = /* @__PURE__ */ new Map();
+    const nodeById = /* @__PURE__ */ new Map();
     for (const node of graph.nodes) {
       if (node.kind === "file" || node.kind === "external") continue;
-      const lexNorm = lexMax > 0 ? (lexRaw.get(node.id) ?? 0) / lexMax : 0;
+      nodeById.set(node.id, node);
       const vec = options.nodeVectors.get(node.id);
       const sem = vec && terms.length > 0 ? Math.max(0, cosine(queryVec, vec)) : 0;
-      const hybrid = 0.5 * lexNorm + 0.5 * sem;
-      if (hybrid <= 0) continue;
-      const lexWhy = whyById.get(node.id);
-      const why = lexWhy || (sem > 0.3 ? `semantic match (${sem.toFixed(2)})` : "weak match");
-      scored.push({ node, score: round(hybrid * (1 + IMPORTANCE_WEIGHT * node.importance)), why });
+      if (sem > 0) semRaw.set(node.id, sem);
+    }
+    const nameOf = (id) => nodeById.get(id)?.qualifiedName ?? id;
+    const lexRanks = ranksOf(lexRaw, nameOf);
+    const semRanks = ranksOf(semRaw, nameOf);
+    for (const [id, node] of nodeById) {
+      const lr = lexRanks.get(id);
+      const sr = semRanks.get(id);
+      if (lr === void 0 && sr === void 0) continue;
+      const fused = (lr !== void 0 ? 1 / (RRF_K + lr) : 0) + (sr !== void 0 ? 1 / (RRF_K + sr) : 0);
+      const sem = semRaw.get(id) ?? 0;
+      const lexWhy = whyById.get(id);
+      const affinity = topicAffinity(id, options.relevance, options.topicTags);
+      const why = (lexWhy || (sem > 0.3 ? `semantic match (${sem.toFixed(2)})` : "weak match")) + affinity.label;
+      scored.push({ node, score: round(fused * affinity.boost * (1 + IMPORTANCE_WEIGHT * node.importance)), why });
     }
     scored.sort((a, b) => b.score - a.score || a.node.qualifiedName.localeCompare(b.node.qualifiedName));
   }
@@ -1001,18 +679,90 @@ function tokenizeOrdered(q) {
 var WEAK_TERM_WEIGHT = 0.25;
 var EXPANSION_WEIGHT = 0.7;
 var COVERAGE_BONUS = 0.35;
-function prepareTerms(forTokens) {
+var CARRY_WEIGHT = 0.5;
+function prepareTerms(forTokens, relevance, prior) {
   const base = tokenize(forTokens);
   const ordered = tokenizeOrdered(forTokens);
   const baseSet = new Set(base);
-  const terms = base.map((t) => ({ term: t, weak: WEAK_TERMS.has(t) }));
+  const consumed = bigramConsumedTokens(ordered);
+  const terms = base.map((t) => ({ term: t, weak: WEAK_TERMS.has(t) || consumed.has(t) }));
+  const have = new Set(base);
   for (const e of expandConcepts(ordered)) {
     if (baseSet.has(e.term)) continue;
     terms.push({ term: e.term, weak: false, from: e.from });
+    have.add(e.term);
+  }
+  for (const e of relevance?.expansions ?? []) {
+    if (have.has(e.term)) continue;
+    terms.push({ term: e.term, weak: false, from: e.from, providerWeight: e.weight });
+    have.add(e.term);
+  }
+  if (prior?.trim()) {
+    const priorOrdered = tokenizeOrdered(prior);
+    const priorConsumed = bigramConsumedTokens(priorOrdered);
+    for (const t of tokenize(prior)) {
+      if (have.has(t) || WEAK_TERMS.has(t) || priorConsumed.has(t)) continue;
+      terms.push({ term: t, weak: false, carried: true });
+      have.add(t);
+    }
+    for (const e of expandConcepts(priorOrdered)) {
+      if (have.has(e.term)) continue;
+      terms.push({ term: e.term, weak: false, from: e.from, carried: true });
+      have.add(e.term);
+    }
   }
   const hasContent = terms.some((t) => !t.weak);
   return { terms, hasContent };
 }
+function priorResidual(prior) {
+  const raw = prior?.trim();
+  if (!raw) return null;
+  return extractLiteralNeedles(raw).length > 0 ? stripLiteralNeedles(raw) : raw;
+}
+function conceptMapLines(question, relevance, priorQuestion) {
+  const cap = (xs) => [...new Set(xs)].slice(0, 8).join(", ");
+  const literals = extractLiteralNeedles(question);
+  const residual = literals.length > 0 ? stripLiteralNeedles(question) : question;
+  const lines = [];
+  const byFrom = /* @__PURE__ */ new Map();
+  for (const e of expandConcepts(tokenizeOrdered(residual))) {
+    const list = byFrom.get(e.from) ?? [];
+    list.push(e.term);
+    byFrom.set(e.from, list);
+  }
+  for (const [from, terms] of byFrom) {
+    lines.push(`- "${from}" in the ask implies these codebase identifiers: ${cap(terms)}.`);
+  }
+  if (relevance?.topics?.length) {
+    const topicVocab = /* @__PURE__ */ new Map();
+    for (const e of relevance.expansions ?? []) {
+      const list = topicVocab.get(e.from) ?? [];
+      list.push(e.term);
+      topicVocab.set(e.from, list);
+    }
+    for (const t of relevance.topics.slice(0, 3)) {
+      const vocab = topicVocab.get(t.id);
+      lines.push(
+        vocab?.length ? `- The ask is about the "${t.id}" domain; code for it typically uses: ${cap(vocab)}.` : `- The ask is about the "${t.id}" domain.`
+      );
+    }
+  }
+  const priorText = priorResidual(priorQuestion);
+  if (priorText) {
+    const current = new Set(tokenize(residual));
+    const consumed = bigramConsumedTokens(tokenizeOrdered(priorText));
+    const carried = tokenize(priorText).filter((t) => !current.has(t) && !WEAK_TERMS.has(t) && !consumed.has(t));
+    if (carried.length) {
+      lines.push(`- This is a follow-up; topic words carried from the previous ask: ${cap(carried)}.`);
+    }
+  }
+  if (lines.length) {
+    lines.push(
+      '- Seed notation below: `a\u2192b` = ask term "a" implied identifier "b"; `~t` = word-form match; `\u21A9t` = carried from the previous ask.'
+    );
+  }
+  return lines;
+}
 function scoreNode(node, terms, weightOf = () => 1) {
   let score = 0;
   let contentHits = 0;
@@ -1022,9 +772,10 @@ function scoreNode(node, terms, weightOf = () => 1) {
   const file = node.file.toLowerCase();
   const dirSegments = new Set(file.split("/").slice(0, -1));
   const nameParts = identifierParts(node.name);
-  for (const { term: t, weak, from } of terms) {
-    const w = weightOf(t) * (weak ? WEAK_TERM_WEIGHT : 1) * (from ? EXPANSION_WEIGHT : 1);
-    const label = from ? `${from}\u2192${t}` : t;
+  for (const { term: t, weak, from, providerWeight, carried } of terms) {
+    const expansionW = providerWeight !== void 0 ? Math.min(providerWeight, EXPANSION_WEIGHT) : from ? EXPANSION_WEIGHT : 1;
+    const w = weightOf(t) * (weak ? WEAK_TERM_WEIGHT : 1) * expansionW * (carried ? CARRY_WEIGHT : 1);
+    const label = (carried ? "\u21A9" : "") + (from ? `${from}\u2192${t}` : t);
     let contribution = 0;
     if (name === t) {
       contribution = 10 * w;
@@ -1040,7 +791,7 @@ function scoreNode(node, terms, weightOf = () => 1) {
       hits.push(label);
     } else if (fuzzyPartMatch(t, nameParts)) {
       contribution = 2 * w;
-      hits.push(from ? `~${from}\u2192${t}` : `~${t}`);
+      hits.push((carried ? "\u21A9" : "") + (from ? `~${from}\u2192${t}` : `~${t}`));
     } else if (dirSegments.has(t)) {
       contribution = 2 * w;
       hits.push(label);
@@ -1058,6 +809,22 @@ function scoreNode(node, terms, weightOf = () => 1) {
   return { score, why: hits.length ? `matched: ${hits.join(", ")}` : "" };
 }
 var IMPORTANCE_WEIGHT = 0.4;
+var TOPIC_AFFINITY_WEIGHT = 0.3;
+function topicAffinity(nodeId, relevance, topicTags) {
+  if (!relevance?.topics?.length || !topicTags) return { boost: 1, label: "" };
+  const tags = topicTags.get(nodeId);
+  if (!tags?.length) return { boost: 1, label: "" };
+  let affinity = 0;
+  const matched = [];
+  for (const t of relevance.topics) {
+    if (tags.includes(t.id)) {
+      affinity += t.score;
+      matched.push(t.id);
+    }
+  }
+  if (affinity <= 0) return { boost: 1, label: "" };
+  return { boost: 1 + TOPIC_AFFINITY_WEIGHT * Math.min(affinity, 1), label: `, topic:${matched.sort().join("+")}` };
+}
 function termWeights(graph, terms) {
   if (terms.length === 0) return () => 1;
   const df = /* @__PURE__ */ new Map();
@@ -1193,6 +960,6 @@ function round2(x) {
   return Math.round(x * 1e6) / 1e6;
 }
 
-export { GraphIndex, acquireLock, clearModelCache, cosine, countPending, embeddingsCached, extractLiteralNeedles, getNodeEmbeddings, identifierParts, impactOf, indexFor, isLocateOnlyInstruction, isModelReady, loadEmbedder, modelCacheInfo, nodeEmbedText, queryGraph, queryGraphSemantic, releaseLock, residualForSymbolSearch, resolveEmbedModel, unavailableMessage, withTimeout };
-//# sourceMappingURL=chunk-SDG242R4.js.map
-//# sourceMappingURL=chunk-SDG242R4.js.map
+export { GraphIndex, acquireLock, clearModelCache, conceptMapLines, cosine, countPending, embeddingsCached, extractLiteralNeedles, getNodeEmbeddings, identifierParts, impactOf, indexFor, isLocateOnlyInstruction, isModelReady, loadEmbedder, modelCacheInfo, nodeEmbedText, queryGraph, queryGraphSemantic, releaseLock, residualForSymbolSearch, resolveEmbedModel, unavailableMessage, withTimeout };
+//# sourceMappingURL=chunk-HC44772H.js.map
+//# sourceMappingURL=chunk-HC44772H.js.map