@skill-map/cli 0.33.0 → 0.34.0

package/dist/kernel/index.js

@@ -93,14 +93,15 @@ var Registry = class {
 };
 
 // kernel/orchestrator/index.ts
-import { existsSync as existsSync10, statSync as statSync4 } from "fs";
+import { existsSync as existsSync11, statSync as statSync4 } from "fs";
+import { isAbsolute as isAbsolute4, resolve as resolve10 } 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.33.0",
+  version: "0.34.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -693,6 +694,391 @@ var ORCHESTRATOR_TEXTS = {
   runScanRootMissing: "runScan: root path '{{root}}' does not exist or is not a directory"
 };
 
+// core/config/active-provider.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+
+// core/config/helper.ts
+import { homedir as osHomedir } from "os";
+import { isAbsolute as isAbsolute2, join as join5, resolve as resolve6 } from "path";
+
+// kernel/config/loader.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+
+// kernel/i18n/config-loader.texts.ts
+var CONFIG_LOADER_TEXTS = {
+  readFailure: "[config:{{layer}}] failed to read {{path}}: {{message}}",
+  invalidJson: "[config:{{layer}}] invalid JSON in {{path}}: {{message}}",
+  expectedObject: "[config:{{layer}}] expected a JSON object, got {{type}}; ignored",
+  unknownKey: "[config:{{layer}}] unknown key {{key}} ignored",
+  invalidValue: "[config:{{layer}}] invalid value at {{path}}: {{message}}",
+  projectLocalOnlyStripped: "[config:{{layer}}] key {{key}} is project-local only; stripped from the committed project layer. Move it to .skill-map/settings.local.json (gitignored, per-checkout)."
+};
+
+// kernel/util/skill-map-paths.ts
+import { join as join4 } from "path";
+
+// core/paths/db-path.ts
+import { join as join3, resolve as resolve5 } from "path";
+var SKILL_MAP_DIR = ".skill-map";
+var DB_FILENAME = "skill-map.db";
+var LOCAL_SETTINGS_FILENAME = "settings.local.json";
+var DEFAULT_DB_REL = `${SKILL_MAP_DIR}/${DB_FILENAME}`;
+var GITIGNORE_ENTRIES = [
+  `${SKILL_MAP_DIR}/${LOCAL_SETTINGS_FILENAME}`,
+  `${SKILL_MAP_DIR}/${DB_FILENAME}`
+];
+
+// kernel/util/skill-map-paths.ts
+var KERNEL_SKILL_MAP_DIR = SKILL_MAP_DIR;
+var SETTINGS_FILENAME = "settings.json";
+var LOCAL_SETTINGS_FILENAME2 = "settings.local.json";
+function kernelSettingsPath(scopeRoot) {
+  return join4(scopeRoot, KERNEL_SKILL_MAP_DIR, SETTINGS_FILENAME);
+}
+function kernelLocalSettingsPath(scopeRoot) {
+  return join4(scopeRoot, KERNEL_SKILL_MAP_DIR, LOCAL_SETTINGS_FILENAME2);
+}
+
+// kernel/util/strip-prototype-pollution.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function stripPrototypePollution(value) {
+  return strip(value);
+}
+function strip(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(strip);
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (FORBIDDEN_KEYS.has(k)) continue;
+    out[k] = strip(v);
+  }
+  return out;
+}
+
+// config/defaults.json
+var defaults_default = {
+  schemaVersion: 1,
+  autoMigrate: true,
+  allowEditSmFiles: false,
+  tokenizer: "cl100k_base",
+  providers: [],
+  roots: [],
+  ignore: [],
+  scan: {
+    tokenize: true,
+    strict: false,
+    followSymlinks: false,
+    maxFileSizeBytes: 1048576,
+    watch: {
+      debounceMs: 300
+    },
+    referencePaths: []
+  },
+  plugins: {},
+  history: {
+    share: false
+  },
+  jobs: {
+    ttlSeconds: 3600,
+    graceMultiplier: 3,
+    minimumTtlSeconds: 60,
+    perActionTtl: {},
+    perActionPriority: {},
+    retention: {
+      completed: 2592e3,
+      failed: null
+    }
+  },
+  i18n: {
+    locale: "en"
+  }
+};
+
+// kernel/config/loader.ts
+var PROJECT_LOCAL_ONLY_KEYS = /* @__PURE__ */ new Set([
+  "allowEditSmFiles",
+  "scan.referencePaths"
+]);
+var DEFAULTS = defaults_default;
+function loadConfig(opts) {
+  const cwd = opts.cwd;
+  const strict = opts.strict ?? false;
+  const warnings = [];
+  const sources = /* @__PURE__ */ new Map();
+  const validators = loadSchemaValidators();
+  let effective = structuredClone(DEFAULTS);
+  recordSources("", effective, sources, "defaults");
+  const filePairs = [
+    { path: kernelSettingsPath(cwd), layer: "project" },
+    { path: kernelLocalSettingsPath(cwd), layer: "project-local" }
+  ];
+  for (const { path, layer } of filePairs) {
+    if (!existsSync3(path)) continue;
+    const partial = readJsonSafe(path, layer, warnings, strict);
+    if (partial === null) continue;
+    const cleaned = validateAndStrip(validators, partial, layer, warnings, strict);
+    if (layer !== "project-local") {
+      stripProjectLocalOnlyKeys(cleaned, layer, warnings, strict);
+    }
+    effective = deepMerge(effective, cleaned);
+    recordSources("", cleaned, sources, layer);
+  }
+  if (opts.overrides && Object.keys(opts.overrides).length > 0) {
+    const cleaned = validateAndStrip(validators, opts.overrides, "override", warnings, strict);
+    stripProjectLocalOnlyKeys(cleaned, "override", warnings, strict);
+    effective = deepMerge(effective, cleaned);
+    recordSources("", cleaned, sources, "override");
+  }
+  return { effective, sources, warnings };
+}
+function readJsonSafe(path, layer, warnings, strict) {
+  let text;
+  try {
+    text = readFileSync5(path, "utf8");
+  } catch (err) {
+    return reportAndSkip(
+      tx(CONFIG_LOADER_TEXTS.readFailure, { layer, path, message: formatErrorMessage(err) }),
+      warnings,
+      strict
+    );
+  }
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return reportAndSkip(
+      tx(CONFIG_LOADER_TEXTS.invalidJson, { layer, path, message: formatErrorMessage(err) }),
+      warnings,
+      strict
+    );
+  }
+}
+function reportAndSkip(msg, warnings, strict) {
+  if (strict) throw new Error(msg);
+  warnings.push(msg);
+  return null;
+}
+function validateAndStrip(validators, raw, layer, warnings, strict) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    const msg = tx(CONFIG_LOADER_TEXTS.expectedObject, { layer, type: describeJsonType(raw) });
+    if (strict) throw new Error(msg);
+    warnings.push(msg);
+    return {};
+  }
+  const cloned = structuredClone(raw);
+  const validator = validators.getValidator("project-config");
+  if (validator(cloned)) return cloned;
+  for (const err of validator.errors ?? []) {
+    applyValidationError(cloned, err, layer, warnings, strict);
+  }
+  return cloned;
+}
+function applyValidationError(cloned, err, layer, warnings, strict) {
+  const path = err.instancePath ?? "";
+  if (err.keyword === "additionalProperties") {
+    const extra = err.params.additionalProperty;
+    deleteAtPath(cloned, path, extra);
+    const msg2 = tx(CONFIG_LOADER_TEXTS.unknownKey, { layer, key: joinSegments(path, extra) });
+    if (strict) throw new Error(msg2);
+    warnings.push(msg2);
+    return;
+  }
+  const segments = path.split("/").filter(Boolean);
+  if (segments.length > 0) {
+    const last = segments.pop();
+    deleteAtPath(cloned, "/" + segments.join("/"), last);
+  }
+  const msg = tx(CONFIG_LOADER_TEXTS.invalidValue, {
+    layer,
+    path: path || "(root)",
+    message: err.message ?? err.keyword
+  });
+  if (strict) throw new Error(msg);
+  warnings.push(msg);
+}
+function describeJsonType(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function deleteAtPath(root, parentPath, key) {
+  if (containsForbidden(parentPath, key)) return;
+  const segments = parentPath.split("/").filter(Boolean);
+  let cur = root;
+  for (const seg of segments) {
+    if (!isPlainObject(cur)) return;
+    cur = cur[seg];
+  }
+  if (isPlainObject(cur)) delete cur[key];
+}
+function stripProjectLocalOnlyKeys(cloned, layer, warnings, strict) {
+  for (const dotKey of PROJECT_LOCAL_ONLY_KEYS) {
+    const segments = dotKey.split(".").filter(Boolean);
+    if (segments.length === 0) continue;
+    const leaf = segments.pop();
+    if (!keyPresentAtPath(cloned, segments, leaf)) continue;
+    const parentPath = "/" + segments.join("/");
+    deleteAtPath(cloned, parentPath, leaf);
+    const msg = tx(CONFIG_LOADER_TEXTS.projectLocalOnlyStripped, {
+      layer,
+      key: dotKey
+    });
+    if (strict) throw new Error(msg);
+    warnings.push(msg);
+  }
+}
+function keyPresentAtPath(root, parentSegments, leaf) {
+  let cur = root;
+  for (const seg of parentSegments) {
+    if (!isPlainObject(cur)) return false;
+    cur = cur[seg];
+  }
+  return isPlainObject(cur) && Object.prototype.hasOwnProperty.call(cur, leaf);
+}
+function isPlainObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function containsForbidden(parentPath, leaf) {
+  if (FORBIDDEN_KEYS.has(leaf)) return true;
+  for (const seg of parentPath.split("/")) {
+    if (FORBIDDEN_KEYS.has(seg)) return true;
+  }
+  return false;
+}
+function joinSegments(instancePath, leaf) {
+  const segments = instancePath.split("/").filter(Boolean);
+  return [...segments, leaf].join(".");
+}
+function deepMerge(target, source) {
+  const out = { ...target };
+  for (const [k, v] of Object.entries(source)) {
+    if (FORBIDDEN_KEYS.has(k)) continue;
+    out[k] = mergeValue(out[k], v);
+  }
+  return out;
+}
+function mergeValue(target, source) {
+  if (source === null || typeof source !== "object" || Array.isArray(source)) {
+    return source;
+  }
+  const targetSlot = target !== null && typeof target === "object" && !Array.isArray(target) ? target : {};
+  return deepMerge(targetSlot, source);
+}
+function recordSources(prefix, value, map, layer) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    if (prefix) map.set(prefix, layer);
+    return;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0 && prefix) {
+    map.set(prefix, layer);
+    return;
+  }
+  for (const [k, v] of entries) {
+    const next = prefix ? `${prefix}.${k}` : k;
+    recordSources(next, v, map, layer);
+  }
+}
+
+// core/config/dot-path.ts
+var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var ForbiddenSegmentError = class extends Error {
+  constructor(segment, key) {
+    super(`forbidden config key segment "${segment}" in "${key}"`);
+    this.segment = segment;
+    this.key = key;
+  }
+  segment;
+  key;
+};
+function assertSafeSegments(segments, key) {
+  for (const seg of segments) {
+    if (FORBIDDEN_SEGMENTS.has(seg)) throw new ForbiddenSegmentError(seg, key);
+  }
+}
+function getAtPath(obj, dotPath) {
+  const segments = dotPath.split(".").filter(Boolean);
+  assertSafeSegments(segments, dotPath);
+  let cur = obj;
+  for (const seg of segments) {
+    if (cur && typeof cur === "object" && !Array.isArray(cur)) {
+      cur = cur[seg];
+      continue;
+    }
+    return void 0;
+  }
+  return cur;
+}
+
+// core/config/atomic-write.ts
+import {
+  closeSync,
+  constants as fsConstants,
+  existsSync as existsSync4,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync6,
+  renameSync,
+  unlinkSync,
+  writeSync
+} from "fs";
+import { randomBytes } from "crypto";
+import { dirname as dirname3 } from "path";
+
+// core/config/helper.ts
+function readConfigValue(key, opts) {
+  const loaded = loadConfigForScope(opts);
+  const value = getAtPath(loaded.effective, key);
+  if (value === void 0) return opts.default;
+  return value;
+}
+function loadConfigForScope(opts) {
+  return loadConfig({
+    cwd: opts.cwd,
+    ...opts.strict ? { strict: true } : {}
+  });
+}
+
+// core/config/active-provider.ts
+var DETECTION_RULES = [
+  { providerId: "claude", marker: ".claude" },
+  { providerId: "gemini", marker: ".gemini" },
+  { providerId: "openai", marker: ".codex" },
+  { providerId: "openai", marker: "AGENTS.md" },
+  { providerId: "cursor", marker: ".cursor" }
+];
+function resolveActiveProvider(cwd) {
+  const detected = detectProvidersFromFilesystem(cwd);
+  const fromConfig = readConfigValue("activeProvider", { cwd });
+  if (typeof fromConfig === "string" && fromConfig.length > 0) {
+    return { resolved: fromConfig, source: "config", detected };
+  }
+  if (detected.length > 0) {
+    return { resolved: detected[0], source: "autodetect", detected };
+  }
+  return { resolved: null, source: "none", detected };
+}
+function detectProvidersFromFilesystem(cwd) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const rule of DETECTION_RULES) {
+    if (seen.has(rule.providerId)) continue;
+    if (!existsSync5(join6(cwd, rule.marker))) continue;
+    seen.add(rule.providerId);
+    out.push(rule.providerId);
+  }
+  return out;
+}
+
 // kernel/types.ts
 var ConfidenceTier = Object.freeze({
   HIGH: 0.9,
@@ -1001,6 +1387,9 @@ function dedupeLinks(links) {
           existing.sources = [...existing.sources, src];
         }
       }
+      if (link.confidence > existing.confidence) {
+        existing.confidence = link.confidence;
+      }
       continue;
     }
     out.set(key, link);
@@ -1195,7 +1584,7 @@ function originatingNodeOf(link, priorNodePaths) {
 function computeCacheDecision(opts) {
   const applicableExtractors = opts.extractors.filter((ex) => {
     if (!matchesKindPrecondition(ex, opts.kind)) return false;
-    if (!matchesProviderPrecondition(ex, opts.provider)) return false;
+    if (!matchesProviderPrecondition(ex, opts.provider, opts.activeProvider)) return false;
     return true;
   });
   const applicableQualifiedIds = new Set(
@@ -1219,10 +1608,12 @@ function matchesKindPrecondition(ex, kind) {
     return kindOnly === kind;
   });
 }
-function matchesProviderPrecondition(ex, provider) {
+function matchesProviderPrecondition(ex, nodeProvider, activeProvider) {
   const providers = ex.precondition?.provider;
   if (!providers || providers.length === 0) return true;
-  return providers.includes(provider);
+  if (!providers.includes(nodeProvider)) return false;
+  if (activeProvider === null) return false;
+  return providers.includes(activeProvider);
 }
 function splitLegacy(applicableExtractors, applicableQualifiedIds, nodeHashCacheEligible) {
   const cachedQualifiedIds = /* @__PURE__ */ new Set();
@@ -1323,6 +1714,75 @@ function classifyLinkSource(source, shortIdToQualified, cachedQualifiedIds, appl
   return "obsolete";
 }
 
+// kernel/trigger-normalize.ts
+function normalizeTrigger(source) {
+  let out = source.normalize("NFD");
+  out = out.replace(new RegExp("\\p{Mn}+", "gu"), "");
+  out = out.toLowerCase();
+  out = out.replace(/[-_\s]+/g, " ");
+  out = out.replace(/  +/g, " ");
+  return out.trim();
+}
+
+// kernel/orchestrator/lift-mention-confidence.ts
+function liftMentionConfidence(links, nodes) {
+  if (!links.some((l) => l.kind === "mentions")) return;
+  const byPath2 = /* @__PURE__ */ new Set();
+  for (const node of nodes) byPath2.add(node.path);
+  const byNormalizedName = indexByNormalizedName(nodes);
+  for (const link of links) {
+    if (link.kind !== "mentions") continue;
+    if (isResolved(link, byPath2, byNormalizedName)) {
+      link.confidence = 1;
+    }
+  }
+}
+function isResolved(link, byPath2, byNormalizedName) {
+  const normalized = link.trigger?.normalizedTrigger;
+  if (normalized) {
+    const withoutSigil = normalized.replace(/^[/@]/, "").trim();
+    if (byNormalizedName.has(withoutSigil)) return true;
+  }
+  if (byPath2.has(link.target)) return true;
+  return false;
+}
+function indexByNormalizedName(nodes) {
+  const out = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const raw = node.frontmatter?.["name"];
+    const name = typeof raw === "string" ? raw : "";
+    if (!name) continue;
+    out.set(normalizeTrigger(name), true);
+  }
+  return out;
+}
+
+// kernel/orchestrator/post-walk-transforms.ts
+var POST_WALK_TRANSFORMS = [
+  {
+    id: "dedupe-links",
+    description: "Collapse identical (source, target, kind, normalizedTrigger) edges across extractors; union sources[] and pick max confidence on merge.",
+    run(links) {
+      return dedupeLinks(links);
+    }
+  },
+  {
+    id: "lift-mention-confidence",
+    description: "Bump resolved `mentions` links to confidence 1.0 once the full node graph is known (post-merge polish).",
+    run(links, nodes) {
+      liftMentionConfidence(links, nodes);
+    }
+  }
+];
+function applyPostWalkTransforms(links, nodes, transforms = POST_WALK_TRANSFORMS) {
+  let current = links;
+  for (const transform of transforms) {
+    const next = transform.run(current, nodes);
+    if (next) current = next;
+  }
+  return current;
+}
+
 // kernel/orchestrator/renames.ts
 function findHighConfidenceRenames(opts) {
   const ops = [];
@@ -1457,11 +1917,11 @@ function detectRenamesAndOrphans(prior, current, issues, silenced) {
 
 // kernel/scan/walk-content.ts
 import { readFile, readdir, lstat } from "fs/promises";
-import { join as join3, relative as relative2, sep } from "path";
+import { join as join7, relative as relative2, sep } from "path";
 
 // kernel/scan/ignore.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname3, resolve as resolve5 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname4, resolve as resolve7 } from "path";
 import { fileURLToPath } from "url";
 import ignoreFactory from "ignore";
 function buildIgnoreFilter(opts = {}) {
@@ -1493,18 +1953,18 @@ function loadDefaultsText() {
   return cachedDefaults;
 }
 function readDefaultsFromDisk() {
-  const here = dirname3(fileURLToPath(import.meta.url));
+  const here = dirname4(fileURLToPath(import.meta.url));
   const candidates = [
-    resolve5(here, "../../config/defaults/skillmapignore"),
+    resolve7(here, "../../config/defaults/skillmapignore"),
     // src/kernel/scan/ → src/config/defaults/
-    resolve5(here, "../config/defaults/skillmapignore"),
+    resolve7(here, "../config/defaults/skillmapignore"),
     // dist/cli.js → dist/config/defaults/ (siblings)
-    resolve5(here, "config/defaults/skillmapignore")
+    resolve7(here, "config/defaults/skillmapignore")
   ];
   for (const candidate of candidates) {
-    if (existsSync3(candidate)) {
+    if (existsSync6(candidate)) {
       try {
-        return readFileSync5(candidate, "utf8");
+        return readFileSync7(candidate, "utf8");
       } catch {
       }
     }
@@ -1514,29 +1974,6 @@ function readDefaultsFromDisk() {
 
 // plugins/core/parsers/frontmatter-yaml/index.ts
 import yaml from "js-yaml";
-
-// kernel/util/strip-prototype-pollution.ts
-var FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype"
-]);
-function stripPrototypePollution(value) {
-  return strip(value);
-}
-function strip(value) {
-  if (value === null || value === void 0) return value;
-  if (typeof value !== "object") return value;
-  if (Array.isArray(value)) return value.map(strip);
-  const out = {};
-  for (const [k, v] of Object.entries(value)) {
-    if (FORBIDDEN_KEYS.has(k)) continue;
-    out[k] = strip(v);
-  }
-  return out;
-}
-
-// plugins/core/parsers/frontmatter-yaml/index.ts
 var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 var frontmatterYamlParser = {
   id: "frontmatter-yaml",
@@ -1668,7 +2105,7 @@ async function* walkRoot(root, current, filter, extensions) {
   }
   for (const entry of entries) {
     const name = entry.name;
-    const full = join3(current, name);
+    const full = join7(current, name);
     const rel = relative2(root, full).split(sep).join("/");
     if (filter.ignores(rel)) continue;
     if (entry.isSymbolicLink()) continue;
@@ -1712,19 +2149,19 @@ function resolveProviderWalk(provider) {
 }
 
 // kernel/sidecar/parse.ts
-import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname4, resolve as resolve6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname5, resolve as resolve8 } from "path";
 import { createRequire as createRequire3 } from "module";
 import { Ajv2020 as Ajv20204 } from "ajv/dist/2020.js";
 import yaml2 from "js-yaml";
 function readSidecarFor(mdAbsolutePath) {
   const sidecarPath = sidecarPathFor(mdAbsolutePath);
-  if (!existsSync4(sidecarPath)) {
+  if (!existsSync7(sidecarPath)) {
     return { parsed: null, present: false, issues: [] };
   }
   let raw;
   try {
-    raw = readFileSync6(sidecarPath, "utf8");
+    raw = readFileSync8(sidecarPath, "utf8");
   } catch (err) {
     return {
       parsed: null,
@@ -1743,7 +2180,7 @@ function readSidecarFor(mdAbsolutePath) {
     };
   }
   parsedYaml = stripPrototypePollution(parsedYaml);
-  if (!isPlainObject(parsedYaml)) {
+  if (!isPlainObject2(parsedYaml)) {
     return {
       parsed: null,
       present: true,
@@ -1762,7 +2199,7 @@ function readSidecarFor(mdAbsolutePath) {
   const root = parsedYaml;
   const identityBlock = root["identity"];
   const annotationsRaw = root["annotations"];
-  const annotations = isPlainObject(annotationsRaw) ? Object.keys(annotationsRaw).length === 0 ? null : annotationsRaw : null;
+  const annotations = isPlainObject2(annotationsRaw) ? Object.keys(annotationsRaw).length === 0 ? null : annotationsRaw : null;
   return {
     parsed: {
       filePath: sidecarPath,
@@ -1782,7 +2219,7 @@ function sidecarPathFor(mdAbsolutePath) {
   }
   return `${mdAbsolutePath}.sm`;
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 var cachedSidecarValidator = null;
@@ -1792,10 +2229,10 @@ function getSidecarValidator() {
   applyAjvFormats(ajv);
   const specRoot = resolveSpecRoot2();
   const annotationsSchema = JSON.parse(
-    readFileSync6(resolve6(specRoot, "schemas/annotations.schema.json"), "utf8")
+    readFileSync8(resolve8(specRoot, "schemas/annotations.schema.json"), "utf8")
   );
   const sidecarSchema = JSON.parse(
-    readFileSync6(resolve6(specRoot, "schemas/sidecar.schema.json"), "utf8")
+    readFileSync8(resolve8(specRoot, "schemas/sidecar.schema.json"), "utf8")
   );
   ajv.addSchema(annotationsSchema);
   cachedSidecarValidator = ajv.compile(sidecarSchema);
@@ -1805,7 +2242,7 @@ function resolveSpecRoot2() {
   const require2 = createRequire3(import.meta.url);
   try {
     const indexPath = require2.resolve("@skill-map/spec/index.json");
-    return dirname4(indexPath);
+    return dirname5(indexPath);
   } catch {
     throw new Error(
       "@skill-map/spec not resolvable: sidecar reader cannot load schemas."
@@ -1824,8 +2261,8 @@ function computeDriftStatus(args) {
 }
 
 // kernel/sidecar/discover-orphans.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { join as join4, relative as relative3, sep as sep2 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { join as join8, relative as relative3, sep as sep2 } from "path";
 function discoverOrphanSidecars(roots, shouldSkip) {
   const out = [];
   for (const root of roots) {
@@ -1841,7 +2278,7 @@ function walk(root, current, shouldSkip, out) {
     return;
   }
   for (const entry of entries) {
-    const full = join4(current, entry.name);
+    const full = join8(current, entry.name);
     const rel = relative3(root, full).split(sep2).join("/");
     if (shouldSkip(rel)) continue;
     if (entry.isSymbolicLink()) continue;
@@ -1852,7 +2289,7 @@ function walk(root, current, shouldSkip, out) {
     if (!entry.isFile()) continue;
     if (!entry.name.endsWith(".sm")) continue;
     const expectedMd = `${full.slice(0, -".sm".length)}.md`;
-    if (existsSync5(expectedMd) && safeIsFile(expectedMd)) continue;
+    if (existsSync8(expectedMd) && safeIsFile(expectedMd)) continue;
     out.push({ sidecarPath: full, relativePath: rel, expectedMdPath: expectedMd });
   }
 }
@@ -1865,51 +2302,15 @@ function safeIsFile(path) {
 }
 
 // kernel/sidecar/store.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
 import { dirname as dirname6, resolve as resolve9 } from "path";
 import { createRequire as createRequire4 } from "module";
 import { Ajv2020 as Ajv20205 } from "ajv/dist/2020.js";
 import yaml3 from "js-yaml";
 
-// core/config/atomic-write.ts
-import {
-  closeSync,
-  constants as fsConstants,
-  existsSync as existsSync6,
-  mkdirSync,
-  openSync,
-  readFileSync as readFileSync7,
-  renameSync,
-  unlinkSync,
-  writeSync
-} from "fs";
-import { randomBytes } from "crypto";
-import { dirname as dirname5 } from "path";
-
-// core/config/helper.ts
-import { homedir as osHomedir } from "os";
-import { isAbsolute as isAbsolute2, join as join7, resolve as resolve8 } from "path";
-
-// kernel/config/loader.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
-
-// kernel/util/skill-map-paths.ts
-import { join as join6 } from "path";
-
-// core/paths/db-path.ts
-import { join as join5, resolve as resolve7 } from "path";
-var SKILL_MAP_DIR = ".skill-map";
-var DB_FILENAME = "skill-map.db";
-var LOCAL_SETTINGS_FILENAME = "settings.local.json";
-var DEFAULT_DB_REL = `${SKILL_MAP_DIR}/${DB_FILENAME}`;
-var GITIGNORE_ENTRIES = [
-  `${SKILL_MAP_DIR}/${LOCAL_SETTINGS_FILENAME}`,
-  `${SKILL_MAP_DIR}/${DB_FILENAME}`
-];
-
 // kernel/orchestrator/node-build.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { isAbsolute as isAbsolute3, resolve as resolvePath } from "path";
 import "js-tiktoken/lite";
 import yaml4 from "js-yaml";
@@ -2073,11 +2474,11 @@ function resolveSidecarOverlay(relativePath, nodePathForIssue, roots, liveBodyHa
 }
 function resolveAbsoluteMdPath(relativePath, roots) {
   if (isAbsolute3(relativePath)) {
-    return existsSync9(relativePath) ? relativePath : null;
+    return existsSync10(relativePath) ? relativePath : null;
   }
   for (const root of roots) {
     const candidate = resolvePath(root, relativePath);
-    if (existsSync9(candidate)) return candidate;
+    if (existsSync10(candidate)) return candidate;
   }
   return null;
 }
@@ -2230,6 +2631,7 @@ async function processRawNode(raw, provider, wctx, accum, claimedPaths, nextInde
     extractors: wctx.opts.extractors,
     kind,
     provider: provider.id,
+    activeProvider: wctx.opts.activeProvider,
     nodePath: raw.path,
     bodyHash,
     sidecarAnnotationsHash,
@@ -2443,9 +2845,10 @@ async function runScanInternal(_kernel, options) {
     priorIndex: setup.priorIndex,
     priorExtractorRuns: setup.priorExtractorRuns,
     providerFrontmatter: setup.providerFrontmatter,
-    pluginStores: options.pluginStores
+    pluginStores: options.pluginStores,
+    activeProvider: resolveActiveProviderOption(options.activeProvider, options.roots)
   });
-  walked.internalLinks = dedupeLinks(walked.internalLinks);
+  walked.internalLinks = applyPostWalkTransforms(walked.internalLinks, walked.nodes);
   recomputeLinkCounts(walked.nodes, walked.internalLinks);
   recomputeExternalRefsCount(walked.nodes, walked.externalLinks, walked.cachedPaths);
   await dispatchExtractorCompleted(exts.extractors, emitter, hookDispatcher);
@@ -2561,17 +2964,27 @@ function validateRoots(roots) {
     throw new Error(ORCHESTRATOR_TEXTS.runScanRootEmptyArray);
   }
   for (const root of roots) {
-    if (!existsSync10(root) || !statSync4(root).isDirectory()) {
+    if (!existsSync11(root) || !statSync4(root).isDirectory()) {
       throw new Error(tx(ORCHESTRATOR_TEXTS.runScanRootMissing, { root }));
     }
   }
 }
+function resolveActiveProviderOption(optionValue, roots) {
+  if (optionValue !== void 0) return optionValue;
+  for (const root of roots) {
+    const absRoot = isAbsolute4(root) ? root : resolve10(root);
+    if (!existsSync11(absRoot)) continue;
+    const detected = resolveActiveProvider(absRoot).resolved;
+    if (detected !== null) return detected;
+  }
+  return null;
+}
 
 // kernel/scan/watcher.ts
-import { resolve as resolve10, relative as relative4, sep as sep3 } from "path";
+import { resolve as resolve11, relative as relative4, sep as sep3 } from "path";
 import chokidar from "chokidar";
 function createChokidarWatcher(opts) {
-  const absRoots = opts.roots.map((r) => resolve10(opts.cwd, r));
+  const absRoots = opts.roots.map((r) => resolve11(opts.cwd, r));
   const ignoreFilterOpt = opts.ignoreFilter;
   const getFilter = ignoreFilterOpt === void 0 ? void 0 : typeof ignoreFilterOpt === "function" ? ignoreFilterOpt : () => ignoreFilterOpt;
   const ignored = getFilter ? (path) => {