@skill-map/cli 0.35.0 → 0.37.0

package/dist/kernel/index.js

@@ -94,14 +94,14 @@ var Registry = class {
 
 // kernel/orchestrator/index.ts
 import { existsSync as existsSync11, statSync as statSync4 } from "fs";
-import { isAbsolute as isAbsolute4, resolve as resolve10 } from "path";
+import { isAbsolute as isAbsolute4, resolve as resolve11 } from "path";
 import { Tiktoken as Tiktoken2 } from "js-tiktoken/lite";
 import cl100k_base from "js-tiktoken/ranks/cl100k_base";
 
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.35.0",
+  version: "0.37.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -197,7 +197,7 @@ var package_default = {
     eslint: "10.2.1",
     "eslint-plugin-import-x": "4.16.2",
     tsup: "8.5.1",
-    tsx: "4.21.0",
+    tsx: "4.22.3",
     typescript: "5.9.3",
     "typescript-eslint": "8.59.1"
   },
@@ -1051,7 +1051,13 @@ function loadConfigForScope(opts) {
 // core/config/active-provider.ts
 var DETECTION_RULES = [
   { providerId: "claude", marker: ".claude" },
-  { providerId: "gemini", marker: ".gemini" },
+  // `gemini` retired 2026-05-22: Google replaced the Gemini CLI with the
+  // Antigravity CLI (released 2026-05-19; Gemini CLI sunsets 2026-06-18).
+  // Antigravity adopted the open-standard `.agents/` instead of a
+  // vendor-specific directory, so detection of a Google CLI project
+  // falls through to the universal `agent-skills` lens (`.agents/`
+  // already classifies via that neutral provider). The lens can still
+  // be set manually via `sm config set activeProvider antigravity`.
   { providerId: "openai", marker: ".codex" },
   { providerId: "openai", marker: "AGENTS.md" },
   { providerId: "cursor", marker: ".cursor" }
@@ -1390,6 +1396,20 @@ function dedupeLinks(links) {
       if (link.confidence > existing.confidence) {
         existing.confidence = link.confidence;
       }
+      if (link.occurrences && link.occurrences.length > 0) {
+        const existingOccurrences = existing.occurrences ?? [];
+        const occKey = (o) => `${o.extractor}\0${o.originalTrigger}\0${o.location?.line ?? -1}`;
+        const occSeen = new Set(existingOccurrences.map(occKey));
+        const merged = [...existingOccurrences];
+        for (const occ of link.occurrences) {
+          const k = occKey(occ);
+          if (!occSeen.has(k)) {
+            occSeen.add(k);
+            merged.push(occ);
+          }
+        }
+        existing.occurrences = merged;
+      }
       continue;
     }
     out.set(key, link);
@@ -1413,12 +1433,23 @@ function recomputeLinkCounts(nodes, links) {
 function recomputeExternalRefsCount(nodes, externalLinks, cachedPaths) {
   const byPath2 = /* @__PURE__ */ new Map();
   for (const node of nodes) {
-    if (!cachedPaths.has(node.path)) node.externalRefsCount = 0;
+    if (!cachedPaths.has(node.path)) {
+      node.externalRefsCount = 0;
+      delete node.externalRefs;
+    }
     byPath2.set(node.path, node);
   }
   for (const link of externalLinks) {
     const source = byPath2.get(link.source);
-    if (source && !cachedPaths.has(source.path)) source.externalRefsCount += 1;
+    if (!source || cachedPaths.has(source.path)) continue;
+    source.externalRefsCount += 1;
+    const refs = source.externalRefs ?? [];
+    refs.push({
+      url: link.target,
+      ...link.location?.line !== void 0 ? { line: link.location.line } : {},
+      ...link.trigger?.originalTrigger ? { originalTrigger: link.trigger.originalTrigger } : {}
+    });
+    source.externalRefs = refs;
   }
 }
 var EXTERNAL_URL_SCHEME_RE = /^[a-z][a-z0-9+\-.]+:/i;
@@ -1429,7 +1460,7 @@ function isExternalUrlLink(link) {
 }
 
 // kernel/orchestrator/analyzers.ts
-async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, orphanJobFiles, referenceablePaths, cwd, registeredActionIds, emitter, hookDispatcher) {
+async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, orphanJobFiles, referenceablePaths, cwd, registeredActionIds, emitter, hookDispatcher, reservedNodePaths, signals) {
   const issues = [];
   const contributions = [];
   const validators = loadSchemaValidators();
@@ -1493,6 +1524,8 @@ async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sid
       orphanJobFiles,
       ...referenceablePaths ? { referenceablePaths } : {},
       ...cwd ? { cwd } : {},
+      ...reservedNodePaths ? { reservedNodePaths } : {},
+      ...signals && signals.length > 0 ? { signals } : {},
       emitContribution
     });
     for (const issue of emitted) {
@@ -1713,7 +1746,7 @@ function classifyLinkSource(source, shortIdToQualified, cachedQualifiedIds, appl
   return "obsolete";
 }
 
-// kernel/orchestrator/lift-resolved-link-confidence.ts
+// kernel/orchestrator/node-identifiers.ts
 import { posix as pathPosix } from "path";
 
 // kernel/trigger-normalize.ts
@@ -1726,14 +1759,54 @@ function normalizeTrigger(source) {
   return out.trim();
 }
 
+// kernel/orchestrator/node-identifiers.ts
+function deriveNodeIdentifiers(node, kindDescriptor) {
+  const sources = kindDescriptor?.identifiers;
+  if (!sources || sources.length === 0) return [];
+  const out = [];
+  for (const source of sources) {
+    const raw = readIdentifier(source, node);
+    if (!raw) continue;
+    const normalised = normalizeTrigger(raw);
+    if (normalised) out.push(normalised);
+  }
+  return out;
+}
+function readIdentifier(source, node) {
+  if (source === "frontmatter.name") return readFrontmatterName(node);
+  if (source === "filename-basename") return readFilenameBasename(node);
+  return readDirname(node);
+}
+function readFrontmatterName(node) {
+  const raw = node.frontmatter?.["name"];
+  if (typeof raw !== "string") return null;
+  return raw.length > 0 ? raw : null;
+}
+function readFilenameBasename(node) {
+  const base = pathPosix.basename(node.path);
+  if (!base) return null;
+  const ext = pathPosix.extname(base);
+  const stem = ext ? base.slice(0, -ext.length) : base;
+  return stem.length > 0 ? stem : null;
+}
+function readDirname(node) {
+  const dir = pathPosix.dirname(node.path);
+  if (!dir || dir === "." || dir === "/") return null;
+  const base = pathPosix.basename(dir);
+  return base.length > 0 ? base : null;
+}
+
 // kernel/orchestrator/lift-resolved-link-confidence.ts
+var RESERVED_TARGET_CONFIDENCE = 0.1;
 function liftResolvedLinkConfidence(links, nodes, ctx) {
   if (!links.some((l) => l.confidence < 1)) return;
   const indexes = buildIndexes(nodes, ctx);
   for (const link of links) {
-    if (link.confidence < 1 && resolves(link, indexes, ctx)) {
-      link.confidence = 1;
-    }
+    if (link.confidence >= 1) continue;
+    const resolution = resolve7(link, indexes, ctx);
+    if (resolution === "none") continue;
+    link.confidence = ctx.reservedNodePaths.has(resolution) ? RESERVED_TARGET_CONFIDENCE : 1;
+    link.resolvedTarget = resolution;
   }
 }
 function buildIndexes(nodes, ctx) {
@@ -1747,18 +1820,19 @@ function buildIndexes(nodes, ctx) {
   }
   return { byPath: byPath2, byName, nodeByPath };
 }
-function resolves(link, indexes, ctx) {
-  if (indexes.byPath.has(link.target)) return true;
-  return resolvesByName(link, indexes, ctx);
+function resolve7(link, indexes, ctx) {
+  if (indexes.byPath.has(link.target)) return link.target;
+  return resolveByName(link, indexes, ctx);
 }
-function resolvesByName(link, indexes, ctx) {
+function resolveByName(link, indexes, ctx) {
   const stripped = stripTriggerSigil(link.trigger?.normalizedTrigger);
-  if (stripped === null) return false;
+  if (stripped === null) return "none";
   const candidates = indexes.byName.get(stripped);
-  if (!candidates?.length) return false;
+  if (!candidates?.length) return "none";
   const allowedKinds = lookupAllowedKinds(link, indexes, ctx);
-  if (!allowedKinds?.length) return false;
-  return candidates.some((c) => allowedKinds.includes(c.kind));
+  if (!allowedKinds?.length) return "none";
+  const winner = candidates.find((c) => allowedKinds.includes(c.kind));
+  return winner ? winner.path : "none";
 }
 function lookupAllowedKinds(link, indexes, ctx) {
   const sourceNode = indexes.nodeByPath.get(link.source);
@@ -1772,44 +1846,17 @@ function stripTriggerSigil(normalized) {
 }
 function indexNode(node, ctx, byName) {
   const kindDescriptor = ctx.kindRegistry.get(kindKey(node));
-  const sources = kindDescriptor?.identifiers;
-  if (!sources || sources.length === 0) return;
-  for (const source of sources) {
-    const raw = deriveIdentifier(source, node);
-    if (!raw) continue;
-    const normalized = normalizeTrigger(raw);
-    if (!normalized) continue;
-    const bucket = byName.get(normalized);
+  const normalised = deriveNodeIdentifiers(node, kindDescriptor);
+  for (const name of normalised) {
+    const entry = { kind: node.kind, path: node.path };
+    const bucket = byName.get(name);
     if (bucket) {
-      bucket.push({ kind: node.kind });
+      bucket.push(entry);
     } else {
-      byName.set(normalized, [{ kind: node.kind }]);
+      byName.set(name, [entry]);
     }
   }
 }
-function deriveIdentifier(source, node) {
-  if (source === "frontmatter.name") return readFrontmatterName(node);
-  if (source === "filename-basename") return readFilenameBasename(node);
-  return readDirname(node);
-}
-function readFrontmatterName(node) {
-  const raw = node.frontmatter?.["name"];
-  if (typeof raw !== "string") return null;
-  return raw.length > 0 ? raw : null;
-}
-function readFilenameBasename(node) {
-  const base = pathPosix.basename(node.path);
-  if (!base) return null;
-  const ext = pathPosix.extname(base);
-  const stem = ext ? base.slice(0, -ext.length) : base;
-  return stem.length > 0 ? stem : null;
-}
-function readDirname(node) {
-  const dir = pathPosix.dirname(node.path);
-  if (!dir || dir === "." || dir === "/") return null;
-  const base = pathPosix.basename(dir);
-  return base.length > 0 ? base : null;
-}
 function kindKey(node) {
   return `${node.provider}/${node.kind}`;
 }
@@ -1840,6 +1887,190 @@ function applyPostWalkTransforms(links, nodes, ctx, transforms = POST_WALK_TRANS
   return current;
 }
 
+// kernel/orchestrator/resolver.ts
+function resolveSignals(opts) {
+  const kindPriority = opts.activeProvider?.resolverRules?.kindPriority ?? [];
+  const extractorRank = buildExtractorRank(opts.extractorOrder);
+  for (const signal of opts.signals) {
+    signal.resolution = pickIntraWinner(signal, kindPriority, extractorRank);
+  }
+  const bySource = /* @__PURE__ */ new Map();
+  for (const signal of opts.signals) {
+    if (signal.resolution?.outcome !== "materialised") continue;
+    const bucket = bySource.get(signal.source) ?? [];
+    bucket.push(signal);
+    bySource.set(signal.source, bucket);
+  }
+  for (const [, signals] of bySource) {
+    const clusters = buildOverlapClusters(signals);
+    for (const cluster of clusters) {
+      if (cluster.length < 2) continue;
+      if (everyCandidateIsExternalUrl(cluster)) continue;
+      resolveCluster(cluster, kindPriority, extractorRank);
+    }
+  }
+  const links = [];
+  for (const signal of opts.signals) {
+    if (signal.resolution?.outcome !== "materialised") continue;
+    const winnerIndex = signal.resolution.winnerIndex ?? 0;
+    const winner = signal.candidates[winnerIndex];
+    if (!winner) continue;
+    links.push(materialise(signal, winner));
+  }
+  return { links, resolvedSignals: [...opts.signals] };
+}
+function buildExtractorRank(order) {
+  const rank = /* @__PURE__ */ new Map();
+  for (let i = 0; i < order.length; i += 1) rank.set(order[i], i);
+  return rank;
+}
+function pickIntraWinner(signal, kindPriority, extractorRank) {
+  let bestIndex = 0;
+  for (let i = 1; i < signal.candidates.length; i += 1) {
+    if (compareCandidates(signal.candidates[i], signal.candidates[bestIndex], kindPriority, extractorRank) < 0) {
+      bestIndex = i;
+    }
+  }
+  return { outcome: "materialised", winnerIndex: bestIndex };
+}
+function compareCandidates(a, b, kindPriority, extractorRank) {
+  const kindCmp = compareKindPriority(a.kind, b.kind, kindPriority);
+  if (kindCmp !== 0) return kindCmp;
+  if (a.confidence !== b.confidence) return b.confidence - a.confidence;
+  const aRank = extractorRank.get(a.extractorId) ?? Number.MAX_SAFE_INTEGER;
+  const bRank = extractorRank.get(b.extractorId) ?? Number.MAX_SAFE_INTEGER;
+  return aRank - bRank;
+}
+function compareKindPriority(aKind, bKind, kindPriority) {
+  if (kindPriority.length === 0) return 0;
+  const aIdx = kindPriority.indexOf(aKind);
+  const bIdx = kindPriority.indexOf(bKind);
+  const aEff = aIdx === -1 ? Number.MAX_SAFE_INTEGER : aIdx;
+  const bEff = bIdx === -1 ? Number.MAX_SAFE_INTEGER : bIdx;
+  return aEff - bEff;
+}
+function buildOverlapClusters(signals) {
+  const bodySignals = signals.filter((s) => s.scope === "body" && s.range);
+  const others = signals.filter((s) => !(s.scope === "body" && s.range));
+  const parent = bodySignals.map((_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  for (let i = 0; i < bodySignals.length; i += 1) {
+    for (let j = i + 1; j < bodySignals.length; j += 1) {
+      if (rangesOverlap(bodySignals[i].range, bodySignals[j].range)) {
+        union(i, j);
+      }
+    }
+  }
+  const byRoot = /* @__PURE__ */ new Map();
+  for (let i = 0; i < bodySignals.length; i += 1) {
+    const root = find(i);
+    const bucket = byRoot.get(root) ?? [];
+    bucket.push(bodySignals[i]);
+    byRoot.set(root, bucket);
+  }
+  return [...byRoot.values(), ...others.map((s) => [s])];
+}
+function rangesOverlap(a, b) {
+  return a.end > b.start && b.end > a.start;
+}
+function everyCandidateIsExternalUrl(cluster) {
+  for (const signal of cluster) {
+    const winnerIndex = signal.resolution?.winnerIndex ?? 0;
+    const winner = signal.candidates[winnerIndex];
+    if (!winner) return false;
+    if (!isExternalUrl(winner.target)) return false;
+  }
+  return true;
+}
+function isExternalUrl(target) {
+  return target.startsWith("http://") || target.startsWith("https://");
+}
+function resolveCluster(cluster, kindPriority, extractorRank) {
+  let winnerIdx = 0;
+  for (let i = 1; i < cluster.length; i += 1) {
+    const result = compareClusterMembers(cluster[i], cluster[winnerIdx], kindPriority, extractorRank);
+    if (result.winner === "challenger") winnerIdx = i;
+  }
+  const winner = cluster[winnerIdx];
+  const winnerCandidate = winner.candidates[winner.resolution?.winnerIndex ?? 0];
+  for (let i = 0; i < cluster.length; i += 1) {
+    if (i === winnerIdx) continue;
+    const loser = cluster[i];
+    loser.resolution = {
+      outcome: "rejected",
+      rejectedBy: {
+        source: winner.source,
+        range: winner.range,
+        extractorId: winnerCandidate.extractorId,
+        reason: whyLost(loser, winner, kindPriority, extractorRank)
+      }
+    };
+  }
+}
+function compareClusterMembers(challenger, champion, kindPriority, extractorRank) {
+  const cWinner = challenger.candidates[challenger.resolution?.winnerIndex ?? 0];
+  const xWinner = champion.candidates[champion.resolution?.winnerIndex ?? 0];
+  const kindCmp = compareKindPriority(cWinner.kind, xWinner.kind, kindPriority);
+  if (kindCmp < 0) return { winner: "challenger", reason: "kind-priority" };
+  if (kindCmp > 0) return { winner: "champion", reason: "kind-priority" };
+  if (cWinner.confidence !== xWinner.confidence) {
+    return cWinner.confidence > xWinner.confidence ? { winner: "challenger", reason: "higher-confidence" } : { winner: "champion", reason: "higher-confidence" };
+  }
+  const cLen = rangeLength(challenger.range);
+  const xLen = rangeLength(champion.range);
+  if (cLen !== xLen) {
+    return cLen > xLen ? { winner: "challenger", reason: "longer-range" } : { winner: "champion", reason: "longer-range" };
+  }
+  const cRank = extractorRank.get(cWinner.extractorId) ?? Number.MAX_SAFE_INTEGER;
+  const xRank = extractorRank.get(xWinner.extractorId) ?? Number.MAX_SAFE_INTEGER;
+  if (cRank !== xRank) {
+    return cRank < xRank ? { winner: "challenger", reason: "earlier-declaration" } : { winner: "champion", reason: "earlier-declaration" };
+  }
+  return { winner: "tie", reason: "earlier-declaration" };
+}
+function rangeLength(range) {
+  if (!range) return 0;
+  return range.end - range.start;
+}
+function whyLost(loser, winner, kindPriority, extractorRank) {
+  return compareClusterMembers(winner, loser, kindPriority, extractorRank).reason;
+}
+function materialise(signal, winner) {
+  const link = {
+    source: signal.source,
+    target: winner.target,
+    kind: winner.kind,
+    confidence: winner.confidence,
+    sources: [winner.extractorId],
+    raw: signal.raw
+  };
+  if (winner.trigger) link.trigger = winner.trigger;
+  if (signal.range) {
+    link.location = { line: signal.range.line ?? 1, offset: signal.range.start };
+  }
+  const occurrenceTrigger = winner.trigger?.originalTrigger ?? signal.raw;
+  const occurrenceLocation = signal.range ? { line: signal.range.line ?? 1 } : null;
+  link.occurrences = [
+    {
+      extractor: winner.extractorId,
+      originalTrigger: occurrenceTrigger,
+      location: occurrenceLocation
+    }
+  ];
+  return link;
+}
+
 // kernel/orchestrator/renames.ts
 function findHighConfidenceRenames(opts) {
   const ops = [];
@@ -1978,7 +2209,7 @@ import { join as join7, relative as relative2, sep } from "path";
 
 // kernel/scan/ignore.ts
 import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname4, resolve as resolve7 } from "path";
+import { dirname as dirname4, resolve as resolve8 } from "path";
 import { fileURLToPath } from "url";
 import ignoreFactory from "ignore";
 function buildIgnoreFilter(opts = {}) {
@@ -2012,11 +2243,11 @@ function loadDefaultsText() {
 function readDefaultsFromDisk() {
   const here = dirname4(fileURLToPath(import.meta.url));
   const candidates = [
-    resolve7(here, "../../config/defaults/skillmapignore"),
+    resolve8(here, "../../config/defaults/skillmapignore"),
     // src/kernel/scan/ → src/config/defaults/
-    resolve7(here, "../config/defaults/skillmapignore"),
+    resolve8(here, "../config/defaults/skillmapignore"),
     // dist/cli.js → dist/config/defaults/ (siblings)
-    resolve7(here, "config/defaults/skillmapignore")
+    resolve8(here, "config/defaults/skillmapignore")
   ];
   for (const candidate of candidates) {
     if (existsSync6(candidate)) {
@@ -2207,7 +2438,7 @@ function resolveProviderWalk(provider) {
 
 // kernel/sidecar/parse.ts
 import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname5, resolve as resolve8 } from "path";
+import { dirname as dirname5, resolve as resolve9 } from "path";
 import { createRequire as createRequire3 } from "module";
 import { Ajv2020 as Ajv20204 } from "ajv/dist/2020.js";
 import yaml2 from "js-yaml";
@@ -2286,10 +2517,10 @@ function getSidecarValidator() {
   applyAjvFormats(ajv);
   const specRoot = resolveSpecRoot2();
   const annotationsSchema = JSON.parse(
-    readFileSync8(resolve8(specRoot, "schemas/annotations.schema.json"), "utf8")
+    readFileSync8(resolve9(specRoot, "schemas/annotations.schema.json"), "utf8")
   );
   const sidecarSchema = JSON.parse(
-    readFileSync8(resolve8(specRoot, "schemas/sidecar.schema.json"), "utf8")
+    readFileSync8(resolve9(specRoot, "schemas/sidecar.schema.json"), "utf8")
   );
   ajv.addSchema(annotationsSchema);
   cachedSidecarValidator = ajv.compile(sidecarSchema);
@@ -2360,7 +2591,7 @@ function safeIsFile(path) {
 
 // kernel/sidecar/store.ts
 import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname6, resolve as resolve9 } from "path";
+import { dirname as dirname6, resolve as resolve10 } from "path";
 import { createRequire as createRequire4 } from "module";
 import { Ajv2020 as Ajv20205 } from "ajv/dist/2020.js";
 import yaml3 from "js-yaml";
@@ -2612,7 +2843,12 @@ async function walkAndExtract(opts) {
   const walkOptions = opts.ignoreFilter ? { ignoreFilter: opts.ignoreFilter } : {};
   let filesWalked = 0;
   let index = 0;
-  for (const provider of opts.providers) {
+  const activeProviders = opts.providers.filter((provider) => {
+    if (!provider.gatedByActiveLens) return true;
+    if (opts.activeProvider === null) return true;
+    return provider.id === opts.activeProvider;
+  });
+  for (const provider of activeProviders) {
     for await (const raw of resolveProviderWalk(provider)(opts.roots, walkOptions)) {
       filesWalked += 1;
       if (claimedPaths.has(raw.path)) continue;
@@ -2633,7 +2869,8 @@ async function walkAndExtract(opts) {
     contributions: accum.contributionsBuffer,
     freshlyRunTuples: accum.freshlyRunTuples,
     orphanSidecars,
-    sidecarRoots: accum.sidecarRoots
+    sidecarRoots: accum.sidecarRoots,
+    signals: accum.signals
   };
 }
 function createWalkAccumulators() {
@@ -2641,6 +2878,7 @@ function createWalkAccumulators() {
     nodes: [],
     internalLinks: [],
     externalLinks: [],
+    signals: [],
     cachedPaths: /* @__PURE__ */ new Set(),
     frontmatterIssues: [],
     enrichmentBuffer: /* @__PURE__ */ new Map(),
@@ -2786,6 +3024,7 @@ function recordFreshlyRunTuples(extractors, nodePath, accum) {
 function mergeExtractResult(extractResult, accum) {
   for (const link of extractResult.internalLinks) accum.internalLinks.push(link);
   for (const link of extractResult.externalLinks) accum.externalLinks.push(link);
+  for (const signal of extractResult.signals) accum.signals.push(signal);
   for (const enr of extractResult.enrichments) {
     accum.enrichmentBuffer.set(`${enr.nodePath}\0${enr.extractorId}`, enr);
   }
@@ -2888,6 +3127,7 @@ async function runScanInternal(_kernel, options) {
   const scanStartedEvent = makeEvent("scan.started", { roots: options.roots });
   emitter.emit(scanStartedEvent);
   await hookDispatcher.dispatch("scan.started", scanStartedEvent);
+  const activeProviderId = resolveActiveProviderOption(options.activeProvider, options.roots);
   const walked = await walkAndExtract({
     providers: exts.providers,
     extractors: exts.extractors,
@@ -2902,9 +3142,20 @@ async function runScanInternal(_kernel, options) {
     priorExtractorRuns: setup.priorExtractorRuns,
     providerFrontmatter: setup.providerFrontmatter,
     pluginStores: options.pluginStores,
-    activeProvider: resolveActiveProviderOption(options.activeProvider, options.roots)
+    activeProvider: activeProviderId
   });
-  const postWalkCtx = buildPostWalkTransformCtx(_kernel);
+  const activeProvider = activeProviderId ? exts.providers.find((p) => p.id === activeProviderId) ?? null : null;
+  const resolved = resolveSignals({
+    signals: walked.signals,
+    activeProvider,
+    extractorOrder: exts.extractors.map((e) => e.id)
+  });
+  for (const link of resolved.links) {
+    if (isExternalUrlLink(link)) walked.externalLinks.push(link);
+    else walked.internalLinks.push(link);
+  }
+  walked.signals = resolved.resolvedSignals;
+  const postWalkCtx = buildPostWalkTransformCtx(exts.providers, walked.nodes);
   walked.internalLinks = applyPostWalkTransforms(walked.internalLinks, walked.nodes, postWalkCtx);
   recomputeLinkCounts(walked.nodes, walked.internalLinks);
   recomputeExternalRefsCount(walked.nodes, walked.externalLinks, walked.cachedPaths);
@@ -2925,7 +3176,9 @@ async function runScanInternal(_kernel, options) {
     options.cwd,
     registeredActionIds,
     emitter,
-    hookDispatcher
+    hookDispatcher,
+    postWalkCtx.reservedNodePaths,
+    walked.signals
   );
   mergeAnalyzerEmissions(walked, analyzerResult, exts.analyzers);
   const issues = analyzerResult.issues;
@@ -2938,10 +3191,19 @@ async function runScanInternal(_kernel, options) {
   await hookDispatcher.dispatch("scan.completed", scanCompletedEvent);
   return buildScanReturn(walked, issues, renameOps, stats, options, setup);
 }
-function buildPostWalkTransformCtx(kernel) {
+function buildPostWalkTransformCtx(providers, nodes) {
+  const { kindRegistry, providerResolution, reservedNamesByProviderKind } = buildProviderIndexes(providers);
+  const reservedNodePaths = buildReservedNodePaths(
+    nodes,
+    kindRegistry,
+    reservedNamesByProviderKind
+  );
+  return { kindRegistry, providerResolution, reservedNodePaths };
+}
+function buildProviderIndexes(providers) {
   const kindRegistry = /* @__PURE__ */ new Map();
   const providerResolution = /* @__PURE__ */ new Map();
-  const providers = kernel.registry.all("provider");
+  const reservedNamesByProviderKind = /* @__PURE__ */ new Map();
   for (const provider of providers) {
     if (provider.kinds) {
       for (const [kindName, descriptor] of Object.entries(provider.kinds)) {
@@ -2951,8 +3213,32 @@ function buildPostWalkTransformCtx(kernel) {
     if (provider.resolution) {
       providerResolution.set(provider.id, provider.resolution);
     }
+    if (provider.reservedNames) {
+      indexReservedNames(provider, reservedNamesByProviderKind);
+    }
+  }
+  return { kindRegistry, providerResolution, reservedNamesByProviderKind };
+}
+function indexReservedNames(provider, out) {
+  for (const [kindName, list] of Object.entries(provider.reservedNames ?? {})) {
+    const normalised = new Set(list.map((raw) => normalizeTrigger(raw)).filter(Boolean));
+    if (normalised.size > 0) {
+      out.set(`${provider.id}/${kindName}`, normalised);
+    }
   }
-  return { kindRegistry, providerResolution };
+}
+function buildReservedNodePaths(nodes, kindRegistry, reservedNamesByProviderKind) {
+  const out = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const key = `${node.provider}/${node.kind}`;
+    const reservedSet = reservedNamesByProviderKind.get(key);
+    if (!reservedSet || reservedSet.size === 0) continue;
+    const ids = deriveNodeIdentifiers(node, kindRegistry.get(key));
+    if (ids.some((id) => reservedSet.has(id))) {
+      out.add(node.path);
+    }
+  }
+  return out;
 }
 function buildScanSetup(options) {
   const start = Date.now();
@@ -3045,7 +3331,7 @@ function validateRoots(roots) {
 function resolveActiveProviderOption(optionValue, roots) {
   if (optionValue !== void 0) return optionValue;
   for (const root of roots) {
-    const absRoot = isAbsolute4(root) ? root : resolve10(root);
+    const absRoot = isAbsolute4(root) ? root : resolve11(root);
     if (!existsSync11(absRoot)) continue;
     const detected = resolveActiveProvider(absRoot).resolved;
     if (detected !== null) return detected;
@@ -3054,10 +3340,10 @@ function resolveActiveProviderOption(optionValue, roots) {
 }
 
 // kernel/scan/watcher.ts
-import { resolve as resolve11, relative as relative4, sep as sep3 } from "path";
+import { resolve as resolve12, relative as relative4, sep as sep3 } from "path";
 import chokidar from "chokidar";
 function createChokidarWatcher(opts) {
-  const absRoots = opts.roots.map((r) => resolve11(opts.cwd, r));
+  const absRoots = opts.roots.map((r) => resolve12(opts.cwd, r));
   const ignoreFilterOpt = opts.ignoreFilter;
   const getFilter = ignoreFilterOpt === void 0 ? void 0 : typeof ignoreFilterOpt === "function" ? ignoreFilterOpt : () => ignoreFilterOpt;
   const ignored = getFilter ? (path) => {