@skill-map/cli 0.20.1 → 0.22.0

package/dist/kernel/index.js

@@ -92,18 +92,15 @@ var Registry = class {
   }
 };
 
-// kernel/orchestrator.ts
-import { createHash } from "crypto";
-import { existsSync as existsSync6, statSync as statSync2 } from "fs";
-import { isAbsolute as isAbsolute2, resolve as resolvePath } from "path";
-import { Tiktoken } from "js-tiktoken/lite";
+// kernel/orchestrator/index.ts
+import { existsSync as existsSync9, statSync as statSync2 } from "fs";
+import { Tiktoken as Tiktoken2 } from "js-tiktoken/lite";
 import cl100k_base from "js-tiktoken/ranks/cl100k_base";
-import yaml4 from "js-yaml";
 
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.20.1",
+  version: "0.22.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -156,20 +153,21 @@ var package_default = {
     "lint:fix": "eslint . --fix",
     reference: "node scripts/build-reference.js",
     "reference:check": "node scripts/build-reference.js --check",
-    validate: "npm run typecheck && npm run lint && npm run build && npm run test:ci && npm run reference:check",
+    validate: "npm run validate:compile && npm run validate:test",
+    "validate:compile": "npm run typecheck && npm run lint && npm run build && npm run reference:check",
+    "validate:test": "npm run test:ci",
     pretest: "tsup",
-    "pretest:ci": "tsup",
     "pretest:coverage": "tsup",
     "pretest:coverage:html": "tsup",
     test: "tsc --noEmit && node --import tsx --test --test-reporter=spec 'test/**/*.test.ts' 'built-in-plugins/**/*.test.ts' 'kernel/**/*.test.ts' 'server/**/*.test.ts'",
-    "test:ci": "tsc --noEmit && node --import tsx --test 'test/**/*.test.ts' 'built-in-plugins/**/*.test.ts' 'kernel/**/*.test.ts' 'server/**/*.test.ts'",
+    "test:ci": "node --import tsx --test 'test/**/*.test.ts' 'built-in-plugins/**/*.test.ts' 'kernel/**/*.test.ts' 'server/**/*.test.ts'",
     "test:coverage": "tsc --noEmit && SKILL_MAP_SKIP_BENCHMARK=1 node --experimental-default-config-file --import tsx --test --experimental-test-coverage 'test/**/*.test.ts' 'built-in-plugins/**/*.test.ts' 'kernel/**/*.test.ts' 'server/**/*.test.ts'",
     "test:coverage:html": "tsc --noEmit && SKILL_MAP_SKIP_BENCHMARK=1 c8 node --import tsx --test 'test/**/*.test.ts' 'built-in-plugins/**/*.test.ts' 'kernel/**/*.test.ts' 'server/**/*.test.ts'",
     clean: "rm -rf dist coverage"
   },
   dependencies: {
     "@hono/node-server": "2.0.1",
-    "@skill-map/spec": "0.20.0",
+    "@skill-map/spec": "0.22.0",
     ajv: "8.18.0",
     "ajv-formats": "3.0.1",
     chokidar: "5.0.0",
@@ -206,174 +204,6 @@ var package_default = {
   }
 };
 
-// kernel/sidecar/parse.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, resolve } from "path";
-import { createRequire } from "module";
-import { Ajv2020 } from "ajv/dist/2020.js";
-import yaml from "js-yaml";
-
-// kernel/util/ajv-interop.ts
-import addFormatsModule from "ajv-formats";
-var addFormats = addFormatsModule.default ?? addFormatsModule;
-function applyAjvFormats(ajv) {
-  addFormats(ajv);
-}
-
-// kernel/sidecar/parse.ts
-function readSidecarFor(mdAbsolutePath) {
-  const sidecarPath = sidecarPathFor(mdAbsolutePath);
-  if (!existsSync(sidecarPath)) {
-    return { parsed: null, present: false, issues: [] };
-  }
-  let raw;
-  try {
-    raw = readFileSync(sidecarPath, "utf8");
-  } catch (err) {
-    return {
-      parsed: null,
-      present: true,
-      issues: [{ message: `cannot read ${sidecarPath}: ${err.message}` }]
-    };
-  }
-  let parsedYaml;
-  try {
-    parsedYaml = yaml.load(raw);
-  } catch (err) {
-    return {
-      parsed: null,
-      present: true,
-      issues: [{ message: `malformed YAML in ${sidecarPath}: ${err.message}` }]
-    };
-  }
-  if (!isPlainObject(parsedYaml)) {
-    return {
-      parsed: null,
-      present: true,
-      issues: [{ message: `sidecar root must be a YAML mapping at ${sidecarPath}` }]
-    };
-  }
-  const sidecarValidator = getSidecarValidator();
-  if (!sidecarValidator(parsedYaml)) {
-    const errors = (sidecarValidator.errors ?? []).map((e) => `${e.instancePath || "(root)"} ${e.message ?? e.keyword}`).join("; ");
-    return {
-      parsed: null,
-      present: true,
-      issues: [{ message: `sidecar schema validation failed at ${sidecarPath}: ${errors}` }]
-    };
-  }
-  const root = parsedYaml;
-  const identityBlock = root["identity"];
-  const annotationsRaw = root["annotations"];
-  const annotations = isPlainObject(annotationsRaw) ? Object.keys(annotationsRaw).length === 0 ? null : annotationsRaw : null;
-  return {
-    parsed: {
-      filePath: sidecarPath,
-      identityBodyHash: String(identityBlock["bodyHash"]),
-      identityFrontmatterHash: String(identityBlock["frontmatterHash"]),
-      identityPath: String(identityBlock["path"]),
-      annotations,
-      raw: root
-    },
-    present: true,
-    issues: []
-  };
-}
-function sidecarPathFor(mdAbsolutePath) {
-  if (mdAbsolutePath.endsWith(".md")) {
-    return `${mdAbsolutePath.slice(0, -".md".length)}.sm`;
-  }
-  return `${mdAbsolutePath}.sm`;
-}
-function isPlainObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-var cachedSidecarValidator = null;
-function getSidecarValidator() {
-  if (cachedSidecarValidator) return cachedSidecarValidator;
-  const ajv = new Ajv2020({ strict: false, allErrors: true, allowUnionTypes: true });
-  applyAjvFormats(ajv);
-  const specRoot = resolveSpecRoot();
-  const annotationsSchema = JSON.parse(
-    readFileSync(resolve(specRoot, "schemas/annotations.schema.json"), "utf8")
-  );
-  const sidecarSchema = JSON.parse(
-    readFileSync(resolve(specRoot, "schemas/sidecar.schema.json"), "utf8")
-  );
-  ajv.addSchema(annotationsSchema);
-  cachedSidecarValidator = ajv.compile(sidecarSchema);
-  return cachedSidecarValidator;
-}
-function resolveSpecRoot() {
-  const require2 = createRequire(import.meta.url);
-  try {
-    const indexPath = require2.resolve("@skill-map/spec/index.json");
-    return dirname(indexPath);
-  } catch {
-    throw new Error(
-      "@skill-map/spec not resolvable \u2014 sidecar reader cannot load schemas."
-    );
-  }
-}
-
-// kernel/sidecar/drift.ts
-function computeDriftStatus(args) {
-  const bodyDrift = args.storedBodyHash !== args.liveBodyHash;
-  const fmDrift = args.storedFrontmatterHash !== args.liveFrontmatterHash;
-  if (bodyDrift && fmDrift) return "stale-both";
-  if (bodyDrift) return "stale-body";
-  if (fmDrift) return "stale-frontmatter";
-  return "fresh";
-}
-
-// kernel/sidecar/discover-orphans.ts
-import { existsSync as existsSync2, readdirSync, statSync } from "fs";
-import { join, relative, sep } from "path";
-function discoverOrphanSidecars(roots, shouldSkip) {
-  const out = [];
-  for (const root of roots) {
-    walk(root, root, shouldSkip ?? (() => false), out);
-  }
-  return out;
-}
-function walk(root, current, shouldSkip, out) {
-  let entries;
-  try {
-    entries = readdirSync(current, { withFileTypes: true, encoding: "utf8" });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    const full = join(current, entry.name);
-    const rel = relative(root, full).split(sep).join("/");
-    if (shouldSkip(rel)) continue;
-    if (entry.isSymbolicLink()) continue;
-    if (entry.isDirectory()) {
-      walk(root, full, shouldSkip, out);
-      continue;
-    }
-    if (!entry.isFile()) continue;
-    if (!entry.name.endsWith(".sm")) continue;
-    const expectedMd = `${full.slice(0, -".sm".length)}.md`;
-    if (existsSync2(expectedMd) && safeIsFile(expectedMd)) continue;
-    out.push({ sidecarPath: full, relativePath: rel, expectedMdPath: expectedMd });
-  }
-}
-function safeIsFile(path) {
-  try {
-    return statSync(path).isFile();
-  } catch {
-    return false;
-  }
-}
-
-// kernel/sidecar/store.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, renameSync, writeFileSync, unlinkSync } from "fs";
-import { dirname as dirname2, resolve as resolve2 } from "path";
-import { createRequire as createRequire2 } from "module";
-import { Ajv2020 as Ajv20202 } from "ajv/dist/2020.js";
-import yaml2 from "js-yaml";
-
 // kernel/adapters/in-memory-progress.ts
 var InMemoryProgressEmitter = class {
   #listeners = /* @__PURE__ */ new Set();
@@ -388,46 +218,56 @@ var InMemoryProgressEmitter = class {
   }
 };
 
-// kernel/adapters/silent-logger.ts
-var SilentLogger = class {
-  trace() {
-  }
-  debug() {
-  }
-  info() {
-  }
-  warn() {
-  }
-  error() {
-  }
-};
+// kernel/adapters/plugin-loader/index.ts
+import { createRequire } from "module";
+import { existsSync, readFileSync as readFileSync2, readdirSync } from "fs";
+import { join, resolve as resolve3 } from "path";
+import { pathToFileURL } from "url";
+import semver from "semver";
 
-// kernel/util/logger.ts
-var active = new SilentLogger();
-var log = {
-  trace: (message, context) => active.trace(message, context),
-  debug: (message, context) => active.debug(message, context),
-  info: (message, context) => active.info(message, context),
-  warn: (message, context) => active.warn(message, context),
-  error: (message, context) => active.error(message, context)
-};
-function configureLogger(impl) {
-  active = impl;
-}
-function resetLogger() {
-  active = new SilentLogger();
-}
-function getActiveLogger() {
-  return active;
+// kernel/adapters/plugin-loader/id-utils.ts
+import { isAbsolute, relative, resolve } from "path";
+
+// kernel/adapters/plugin-loader/validation.ts
+import { Ajv2020 } from "ajv/dist/2020.js";
+
+// kernel/util/ajv-interop.ts
+import addFormatsModule from "ajv-formats";
+var addFormats = addFormatsModule.default ?? addFormatsModule;
+function applyAjvFormats(ajv) {
+  addFormats(ajv);
 }
 
-// kernel/adapters/plugin-loader.ts
-import { createRequire as createRequire3 } from "module";
-import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
-import { isAbsolute, join as join2, relative as relative2, resolve as resolve3 } from "path";
-import { pathToFileURL } from "url";
-import { Ajv2020 as Ajv20203 } from "ajv/dist/2020.js";
-import semver from "semver";
+// kernel/extensions/hook.ts
+var HOOK_TRIGGERS = Object.freeze([
+  "boot",
+  "scan.started",
+  "scan.completed",
+  "extractor.completed",
+  "analyzer.completed",
+  "action.completed",
+  "job.spawning",
+  "job.completed",
+  "job.failed",
+  "shutdown"
+]);
+
+// kernel/adapters/plugin-loader/validation.ts
+var KNOWN_KINDS = /* @__PURE__ */ new Set([
+  "provider",
+  "extractor",
+  "analyzer",
+  "action",
+  "formatter",
+  "hook"
+]);
+var KNOWN_KINDS_LIST = [...KNOWN_KINDS].join(" / ");
+var HOOKABLE_TRIGGERS_LIST = HOOK_TRIGGERS.join(", ");
+
+// kernel/adapters/plugin-loader/storage-schemas.ts
+import { readFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { Ajv2020 as Ajv20202 } from "ajv/dist/2020.js";
 
 // kernel/i18n/plugin-store.texts.ts
 var PLUGIN_STORE_TEXTS = {
@@ -506,37 +346,20 @@ function formatAjvErrors(errors) {
   return errors.map((e) => `${e.instancePath || "(root)"} ${e.message ?? e.keyword}`).join("; ");
 }
 
-// kernel/extensions/hook.ts
-var HOOK_TRIGGERS = Object.freeze([
-  "boot",
-  "scan.started",
-  "scan.completed",
-  "extractor.completed",
-  "analyzer.completed",
-  "action.completed",
-  "job.spawning",
-  "job.completed",
-  "job.failed",
-  "shutdown"
-]);
-
-// kernel/adapters/plugin-loader.ts
-var KNOWN_KINDS = /* @__PURE__ */ new Set(["provider", "extractor", "analyzer", "action", "formatter", "hook"]);
-var KNOWN_KINDS_LIST = [...KNOWN_KINDS].join(" / ");
-var HOOKABLE_TRIGGERS_LIST = HOOK_TRIGGERS.join(", ");
+// kernel/adapters/plugin-loader/index.ts
 function installedSpecVersion() {
-  const require2 = createRequire3(import.meta.url);
+  const require2 = createRequire(import.meta.url);
   const indexPath = require2.resolve("@skill-map/spec/index.json");
   const pkgPath = resolve3(indexPath, "..", "package.json");
-  const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
   return pkg.version;
 }
 
 // kernel/adapters/schema-validators.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, resolve as resolve4 } from "path";
-import { createRequire as createRequire4 } from "module";
-import { Ajv2020 as Ajv20204 } from "ajv/dist/2020.js";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname, resolve as resolve4 } from "path";
+import { createRequire as createRequire2 } from "module";
+import { Ajv2020 as Ajv20203 } from "ajv/dist/2020.js";
 var SCHEMA_FILES = {
   node: "schemas/node.schema.json",
   link: "schemas/link.schema.json",
@@ -571,8 +394,8 @@ function loadSchemaValidators() {
   return cachedValidators;
 }
 function buildSchemaValidators() {
-  const specRoot = resolveSpecRoot2();
-  const ajv = new Ajv20204({
+  const specRoot = resolveSpecRoot();
+  const ajv = new Ajv20203({
     strict: false,
     allErrors: true,
     allowUnionTypes: true
@@ -581,13 +404,13 @@ function buildSchemaValidators() {
   for (const rel of SUPPORTING_SCHEMAS) {
     const file = resolve4(specRoot, rel);
     if (!existsSyncSafe(file)) continue;
-    const schema = JSON.parse(readFileSync4(file, "utf8"));
+    const schema = JSON.parse(readFileSync3(file, "utf8"));
     ajv.addSchema(schema);
   }
   const validators = /* @__PURE__ */ new Map();
   for (const [name, rel] of Object.entries(SCHEMA_FILES)) {
     const file = resolve4(specRoot, rel);
-    const schema = JSON.parse(readFileSync4(file, "utf8"));
+    const schema = JSON.parse(readFileSync3(file, "utf8"));
     const byId = typeof schema.$id === "string" ? ajv.getSchema(schema.$id) : void 0;
     validators.set(name, byId ?? ajv.compile(schema));
   }
@@ -607,7 +430,7 @@ function buildSchemaValidators() {
   const KNOWN_SLOTS = /* @__PURE__ */ new Set([
     "card.title.right",
     "card.subtitle.left",
-    "card.footer.left.counter",
+    "card.footer.left",
     "card.footer.right",
     "graph.node.alert",
     "inspector.header.badge.counter",
@@ -618,7 +441,7 @@ function buildSchemaValidators() {
     "inspector.body.panel.key-values",
     "inspector.body.panel.link-list",
     "inspector.body.panel.markdown",
-    "topbar.actions.indicator"
+    "topbar.nav.start"
   ]);
   function getContributionValidator(slot) {
     if (!KNOWN_SLOTS.has(slot)) return null;
@@ -667,15 +490,15 @@ function buildSchemaValidators() {
   };
 }
 function buildProviderFrontmatterValidator(providers) {
-  const specRoot = resolveSpecRoot2();
-  const ajv = new Ajv20204({
+  const specRoot = resolveSpecRoot();
+  const ajv = new Ajv20203({
     strict: false,
     allErrors: true,
     allowUnionTypes: true
   });
   applyAjvFormats(ajv);
   const baseFile = resolve4(specRoot, "schemas/frontmatter/base.schema.json");
-  const baseSchema = JSON.parse(readFileSync4(baseFile, "utf8"));
+  const baseSchema = JSON.parse(readFileSync3(baseFile, "utf8"));
   ajv.addSchema(baseSchema);
   registerProviderAuxiliarySchemas(ajv, providers);
   const compiled = /* @__PURE__ */ new Map();
@@ -712,11 +535,11 @@ function registerProviderAuxiliarySchemas(ajv, providers) {
     }
   }
 }
-function resolveSpecRoot2() {
-  const require2 = createRequire4(import.meta.url);
+function resolveSpecRoot() {
+  const require2 = createRequire2(import.meta.url);
   try {
     const indexPath = require2.resolve("@skill-map/spec/index.json");
-    return dirname3(indexPath);
+    return dirname(indexPath);
   } catch {
     throw new Error(
       "@skill-map/spec not resolvable \u2014 ensure the workspace is linked or the package is installed."
@@ -725,214 +548,49 @@ function resolveSpecRoot2() {
 }
 function existsSyncSafe(path) {
   try {
-    readFileSync4(path, "utf8");
+    readFileSync3(path, "utf8");
     return true;
   } catch {
     return false;
   }
 }
 
-// kernel/i18n/orchestrator.texts.ts
-var ORCHESTRATOR_TEXTS = {
-  frontmatterInvalid: "Frontmatter for {{path}} ({{kind}}) failed schema validation: {{errors}}",
-  frontmatterMalformedPasteWithIndent: "Frontmatter fence in {{path}} appears indented; YAML frontmatter MUST start with `---` at column 0. The file was scanned as body-only \u2014 the metadata block was silently lost. Move the `---` lines to the start of the line.",
-  frontmatterMalformedByteOrderMark: "Frontmatter fence in {{path}} is preceded by a UTF-8 byte-order mark (BOM); the file was scanned as body-only. Re-save the file as UTF-8 without BOM. The metadata block was silently lost.",
-  frontmatterMalformedMissingClose: "Frontmatter in {{path}} opens with `---` but never closes \u2014 no matching `---` line at column 0 was found. The file was scanned as body-only and every metadata field was silently lost. Add a closing `---` line below the metadata block.",
-  extensionErrorLinkKindNotDeclared: 'Extractor "{{extractorId}}" emitted a link of kind "{{linkKind}}" outside its declared `emitsLinkKinds` set [{{declaredKinds}}]. Link dropped.',
-  extensionErrorIssueInvalidSeverity: `Rule "{{analyzerId}}" emitted an issue with invalid severity {{severity}} (allowed: 'error' | 'warn' | 'info'). Issue dropped.`,
-  extensionErrorContributionUnknownId: 'Extractor "{{extractorId}}" emitted contribution "{{contributionId}}" on {{nodePath}} but did not declare it in its `viewContributions` map. Contribution dropped.',
-  extensionErrorContributionPayloadInvalid: 'Extractor "{{extractorId}}" emitted contribution "{{contributionId}}" on {{nodePath}}; payload failed the "{{slot}}" schema: {{errors}}. Contribution dropped.',
-  runScanRootEmptyArray: "runScan: roots must contain at least one path (spec requires minItems: 1)",
-  runScanRootMissing: "runScan: root path '{{root}}' does not exist or is not a directory"
-};
-
 // kernel/util/format-error.ts
 function formatErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-// kernel/scan/walk-content.ts
-import { readFile, readdir, stat } from "fs/promises";
-import { join as join3, relative as relative3, sep as sep2 } from "path";
-
-// kernel/scan/ignore.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname4, resolve as resolve5 } from "path";
-import { fileURLToPath } from "url";
-import ignoreFactory from "ignore";
-function buildIgnoreFilter(opts = {}) {
-  const ig = ignoreFactory();
-  if (opts.includeDefaults !== false) {
-    ig.add(loadDefaultsText());
-  }
-  if (opts.configIgnore && opts.configIgnore.length > 0) {
-    ig.add(opts.configIgnore);
+// kernel/adapters/silent-logger.ts
+var SilentLogger = class {
+  trace() {
   }
-  if (opts.ignoreFileText && opts.ignoreFileText.length > 0) {
-    ig.add(opts.ignoreFileText);
+  debug() {
   }
-  return {
-    ignores(relativePath) {
-      if (relativePath === "" || relativePath === "." || relativePath === "./") {
-        return false;
-      }
-      const normalised = relativePath.replace(/^\.\//, "").replace(/\\/g, "/").replace(/^\//, "");
-      if (normalised === "") return false;
-      return ig.ignores(normalised);
-    }
-  };
-}
-var cachedDefaults = null;
-function loadDefaultsText() {
-  if (cachedDefaults !== null) return cachedDefaults;
-  cachedDefaults = readDefaultsFromDisk();
-  return cachedDefaults;
-}
-function readDefaultsFromDisk() {
-  const here = dirname4(fileURLToPath(import.meta.url));
-  const candidates = [
-    resolve5(here, "../../config/defaults/skillmapignore"),
-    // src/kernel/scan/ → src/config/defaults/
-    resolve5(here, "../config/defaults/skillmapignore"),
-    // dist/cli.js → dist/config/defaults/ (siblings)
-    resolve5(here, "config/defaults/skillmapignore")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync5(candidate)) {
-      try {
-        return readFileSync5(candidate, "utf8");
-      } catch {
-      }
-    }
+  info() {
   }
-  return "";
-}
-
-// built-in-plugins/parsers/frontmatter-yaml/index.ts
-import yaml3 from "js-yaml";
-var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-var FORBIDDEN_FRONTMATTER_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-var frontmatterYamlParser = {
-  id: "frontmatter-yaml",
-  parse(raw, _path) {
-    const match = FRONTMATTER_RE.exec(raw);
-    if (!match) return { frontmatterRaw: "", frontmatter: {}, body: raw };
-    const frontmatterRaw = match[1];
-    const body = match[2];
-    const parsed = {};
-    try {
-      const doc = yaml3.load(frontmatterRaw, { schema: yaml3.JSON_SCHEMA });
-      if (doc && typeof doc === "object" && !Array.isArray(doc)) {
-        for (const [k, v] of Object.entries(doc)) {
-          if (FORBIDDEN_FRONTMATTER_KEYS.has(k)) continue;
-          parsed[k] = v;
-        }
-      }
-    } catch {
-    }
-    return { frontmatterRaw, frontmatter: parsed, body };
+  warn() {
   }
-};
-
-// built-in-plugins/parsers/plain/index.ts
-var plainParser = {
-  id: "plain",
-  parse(raw, _path) {
-    return { frontmatter: {}, frontmatterRaw: "", body: raw };
+  error() {
   }
 };
 
-// kernel/scan/parsers/index.ts
-var REGISTRY = /* @__PURE__ */ new Map([
-  [frontmatterYamlParser.id, frontmatterYamlParser],
-  [plainParser.id, plainParser]
-]);
-var FROZEN_IDS = new Set(REGISTRY.keys());
-function getParser(id) {
-  return REGISTRY.get(id);
-}
-
-// kernel/scan/walk-content.ts
-var UnknownParserError = class extends Error {
-  constructor(parserId) {
-    super(`Unknown parser id '${parserId}'. Built-in parsers: 'frontmatter-yaml', 'plain'.`);
-    this.name = "UnknownParserError";
-  }
+// kernel/util/logger.ts
+var active = new SilentLogger();
+var log = {
+  trace: (message, context) => active.trace(message, context),
+  debug: (message, context) => active.debug(message, context),
+  info: (message, context) => active.info(message, context),
+  warn: (message, context) => active.warn(message, context),
+  error: (message, context) => active.error(message, context)
 };
-async function* walkContent(roots, options) {
-  const parser = getParser(options.parser);
-  if (!parser) throw new UnknownParserError(options.parser);
-  const filter = options.ignoreFilter ?? buildIgnoreFilter();
-  const extensions = options.extensions;
-  for (const root of roots) {
-    for await (const file of walkRoot(root, root, filter, extensions)) {
-      const relPath = relative3(root, file).split(sep2).join("/");
-      let raw;
-      try {
-        raw = await readFile(file, "utf8");
-      } catch {
-        continue;
-      }
-      const parsed = parser.parse(raw, relPath);
-      yield {
-        path: relPath,
-        body: parsed.body,
-        frontmatterRaw: parsed.frontmatterRaw,
-        frontmatter: parsed.frontmatter
-      };
-    }
-  }
-}
-async function* walkRoot(root, current, filter, extensions) {
-  let entries;
-  try {
-    entries = await readdir(current, { withFileTypes: true, encoding: "utf8" });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    const name = entry.name;
-    const full = join3(current, name);
-    const rel = relative3(root, full).split(sep2).join("/");
-    if (filter.ignores(rel)) continue;
-    if (entry.isSymbolicLink()) continue;
-    if (entry.isDirectory()) {
-      yield* walkRoot(root, full, filter, extensions);
-    } else if (entry.isFile() && hasMatchingExtension(name, extensions)) {
-      try {
-        const s = await stat(full);
-        if (s.isFile()) yield full;
-      } catch {
-      }
-    }
-  }
+function configureLogger(impl) {
+  active = impl;
 }
-function hasMatchingExtension(name, extensions) {
-  for (const ext of extensions) {
-    if (name.endsWith(ext)) return true;
-  }
-  return false;
+function resetLogger() {
+  active = new SilentLogger();
 }
-
-// kernel/extensions/provider.ts
-var DEFAULT_READ_CONFIG = Object.freeze({
-  extensions: Object.freeze([".md"]),
-  parser: "frontmatter-yaml"
-});
-function resolveProviderWalk(provider) {
-  if (provider.walk) {
-    const walk2 = provider.walk.bind(provider);
-    return walk2;
-  }
-  const read = provider.read ?? DEFAULT_READ_CONFIG;
-  return (roots, options) => {
-    const walkOptions = {
-      extensions: read.extensions,
-      parser: read.parser
-    };
-    if (options?.ignoreFilter) walkOptions.ignoreFilter = options.ignoreFilter;
-    return walkContent(roots, walkOptions);
-  };
+function getActiveLogger() {
+  return active;
 }
 
 // kernel/extensions/hook-dispatcher.ts
@@ -1014,166 +672,21 @@ function buildHookContext(_hook, trigger, event) {
   return ctx;
 }
 
-// kernel/orchestrator.ts
-var SCANNED_BY = {
-  name: "skill-map",
-  version: package_default.version,
-  specVersion: resolveSpecVersionSafe()
+// kernel/i18n/orchestrator.texts.ts
+var ORCHESTRATOR_TEXTS = {
+  frontmatterInvalid: "Frontmatter for {{path}} ({{kind}}) failed schema validation: {{errors}}",
+  frontmatterMalformedPasteWithIndent: "Frontmatter fence in {{path}} appears indented; YAML frontmatter MUST start with `---` at column 0. The file was scanned as body-only \u2014 the metadata block was silently lost. Move the `---` lines to the start of the line.",
+  frontmatterMalformedByteOrderMark: "Frontmatter fence in {{path}} is preceded by a UTF-8 byte-order mark (BOM); the file was scanned as body-only. Re-save the file as UTF-8 without BOM. The metadata block was silently lost.",
+  frontmatterMalformedMissingClose: "Frontmatter in {{path}} opens with `---` but never closes \u2014 no matching `---` line at column 0 was found. The file was scanned as body-only and every metadata field was silently lost. Add a closing `---` line below the metadata block.",
+  extensionErrorLinkKindNotDeclared: 'Extractor "{{extractorId}}" emitted a link of kind "{{linkKind}}" outside its declared `emitsLinkKinds` set [{{declaredKinds}}]. Link dropped.',
+  extensionErrorIssueInvalidSeverity: `Rule "{{analyzerId}}" emitted an issue with invalid severity {{severity}} (allowed: 'error' | 'warn' | 'info'). Issue dropped.`,
+  extensionErrorContributionUnknownId: 'Extractor "{{extractorId}}" emitted contribution "{{contributionId}}" on {{nodePath}} but did not declare it in its `viewContributions` map. Contribution dropped.',
+  extensionErrorContributionPayloadInvalid: 'Extractor "{{extractorId}}" emitted contribution "{{contributionId}}" on {{nodePath}}; payload failed the "{{slot}}" schema: {{errors}}. Contribution dropped.',
+  runScanRootEmptyArray: "runScan: roots must contain at least one path (spec requires minItems: 1)",
+  runScanRootMissing: "runScan: root path '{{root}}' does not exist or is not a directory"
 };
-function resolveSpecVersionSafe() {
-  try {
-    return installedSpecVersion();
-  } catch {
-    return "unknown";
-  }
-}
-async function runScanWithRenames(_kernel, options) {
-  return runScanInternal(_kernel, options);
-}
-async function runScan(_kernel, options) {
-  const { result } = await runScanInternal(_kernel, options);
-  return result;
-}
-async function runScanInternal(_kernel, options) {
-  validateRoots(options.roots);
-  const start = Date.now();
-  const scannedAt = start;
-  const emitter = options.emitter ?? new InMemoryProgressEmitter();
-  const exts = options.extensions ?? { providers: [], extractors: [], analyzers: [] };
-  const hookDispatcher = makeHookDispatcher(exts.hooks ?? [], emitter);
-  const tokenize = options.tokenize !== false;
-  const scope = options.scope ?? "project";
-  const strict = options.strict === true;
-  const encoder = tokenize ? new Tiktoken(cl100k_base) : null;
-  const prior = options.priorSnapshot ?? null;
-  const enableCache = options.enableCache === true;
-  const priorExtractorRuns = options.priorExtractorRuns;
-  const priorIndex = indexPriorSnapshot(prior);
-  const providerFrontmatter = buildProviderFrontmatterValidator(exts.providers);
-  const scanStartedEvent = makeEvent("scan.started", { roots: options.roots });
-  emitter.emit(scanStartedEvent);
-  await hookDispatcher.dispatch("scan.started", scanStartedEvent);
-  const walked = await walkAndExtract({
-    providers: exts.providers,
-    extractors: exts.extractors,
-    roots: options.roots,
-    ...options.ignoreFilter ? { ignoreFilter: options.ignoreFilter } : {},
-    emitter,
-    encoder,
-    strict,
-    enableCache,
-    prior,
-    priorIndex,
-    priorExtractorRuns,
-    providerFrontmatter,
-    pluginStores: options.pluginStores
-  });
-  recomputeLinkCounts(walked.nodes, walked.internalLinks);
-  recomputeExternalRefsCount(walked.nodes, walked.externalLinks, walked.cachedPaths);
-  for (const extractor of exts.extractors) {
-    const extractorId = qualifiedExtensionId(extractor.pluginId, extractor.id);
-    const evt = makeEvent("extractor.completed", { extractorId });
-    emitter.emit(evt);
-    await hookDispatcher.dispatch("extractor.completed", evt);
-  }
-  const analyzerResult = await runAnalyzers(
-    exts.analyzers,
-    walked.nodes,
-    walked.internalLinks,
-    walked.orphanSidecars,
-    walked.sidecarRoots,
-    options.annotationContributions ?? [],
-    options.viewContributions ?? [],
-    options.orphanJobFiles ?? [],
-    options.referenceablePaths,
-    options.cwd,
-    emitter,
-    hookDispatcher
-  );
-  const issues = analyzerResult.issues;
-  for (const c of analyzerResult.contributions) walked.contributions.push(c);
-  for (const analyzer of exts.analyzers ?? []) {
-    if (analyzer.viewContributions === void 0) continue;
-    for (const node of walked.nodes) {
-      walked.freshlyRunTuples.add(`${analyzer.pluginId}/${analyzer.id}/${node.path}`);
-    }
-  }
-  for (const issue of walked.frontmatterIssues) issues.push(issue);
-  const renameOps = prior ? detectRenamesAndOrphans(prior, walked.nodes, issues) : [];
-  const stats = {
-    // `filesSkipped` is "files walked but not classified by any Provider".
-    // Today every walked file IS classified by its Provider (the `claude`
-    // Provider's `classify()` always returns a kind, falling back to
-    // `'markdown'`), so this is always 0. Wired now so the field shape is
-    // spec-conformant; meaningful once multiple Providers compete.
-    filesWalked: walked.filesWalked,
-    filesSkipped: 0,
-    nodesCount: walked.nodes.length,
-    linksCount: walked.internalLinks.length,
-    issuesCount: issues.length,
-    durationMs: Date.now() - start
-  };
-  const scanCompletedEvent = makeEvent("scan.completed", { stats });
-  emitter.emit(scanCompletedEvent);
-  await hookDispatcher.dispatch("scan.completed", scanCompletedEvent);
-  return {
-    result: {
-      schemaVersion: 1,
-      scannedAt,
-      scope,
-      roots: options.roots,
-      providers: exts.providers.map((a) => a.id),
-      scannedBy: SCANNED_BY,
-      nodes: walked.nodes,
-      links: walked.internalLinks,
-      issues,
-      stats
-    },
-    renameOps,
-    extractorRuns: walked.extractorRuns,
-    enrichments: walked.enrichments,
-    contributions: walked.contributions,
-    freshlyRunTuples: walked.freshlyRunTuples
-  };
-}
-function validateRoots(roots) {
-  if (roots.length === 0) {
-    throw new Error(ORCHESTRATOR_TEXTS.runScanRootEmptyArray);
-  }
-  for (const root of roots) {
-    if (!existsSync6(root) || !statSync2(root).isDirectory()) {
-      throw new Error(tx(ORCHESTRATOR_TEXTS.runScanRootMissing, { root }));
-    }
-  }
-}
-function indexPriorSnapshot(prior) {
-  const priorNodesByPath = /* @__PURE__ */ new Map();
-  const priorNodePaths = /* @__PURE__ */ new Set();
-  const priorLinksByOriginating = /* @__PURE__ */ new Map();
-  const priorFrontmatterIssuesByNode = /* @__PURE__ */ new Map();
-  if (!prior) {
-    return { priorNodesByPath, priorNodePaths, priorLinksByOriginating, priorFrontmatterIssuesByNode };
-  }
-  for (const node of prior.nodes) {
-    priorNodesByPath.set(node.path, node);
-    priorNodePaths.add(node.path);
-  }
-  for (const link of prior.links) {
-    const key = originatingNodeOf(link, priorNodePaths);
-    const list = priorLinksByOriginating.get(key);
-    if (list) list.push(link);
-    else priorLinksByOriginating.set(key, [link]);
-  }
-  for (const issue of prior.issues) {
-    if (issue.analyzerId !== "frontmatter-invalid" && issue.analyzerId !== "frontmatter-malformed") continue;
-    if (issue.nodeIds.length !== 1) continue;
-    const path = issue.nodeIds[0];
-    const list = priorFrontmatterIssuesByNode.get(path);
-    if (list) list.push(issue);
-    else priorFrontmatterIssuesByNode.set(path, [issue]);
-  }
-  return { priorNodesByPath, priorNodePaths, priorLinksByOriginating, priorFrontmatterIssuesByNode };
-}
+
+// kernel/orchestrator/extractors.ts
 async function runExtractorsForNode(opts) {
   const internalLinks = [];
   const externalLinks = [];
@@ -1292,320 +805,71 @@ function emitExtensionError(emitter, qualifiedId, nodePath, data) {
     })
   );
 }
-function computeCacheDecision(opts) {
-  const applicableExtractors = opts.extractors.filter(
-    (ex) => ex.applicableKinds === void 0 || ex.applicableKinds.includes(opts.kind)
-  );
-  const applicableQualifiedIds = new Set(
-    applicableExtractors.map((ex) => qualifiedExtensionId(ex.pluginId, ex.id))
-  );
-  const cachedQualifiedIds = /* @__PURE__ */ new Set();
-  const missingExtractors = [];
-  if (opts.priorExtractorRuns === void 0) {
-    if (opts.nodeHashCacheEligible) {
-      for (const id of applicableQualifiedIds) cachedQualifiedIds.add(id);
-    } else {
-      for (const ex of applicableExtractors) missingExtractors.push(ex);
-    }
-  } else {
-    const priorRunsForNode = opts.priorExtractorRuns.get(opts.nodePath) ?? /* @__PURE__ */ new Map();
-    for (const ex of applicableExtractors) {
-      const qualified = qualifiedExtensionId(ex.pluginId, ex.id);
-      const priorBody = priorRunsForNode.get(qualified);
-      if (opts.nodeHashCacheEligible && priorBody === opts.bodyHash) {
-        cachedQualifiedIds.add(qualified);
-      } else {
-        missingExtractors.push(ex);
-      }
-    }
-  }
+function buildExtractorContext(extractor, node, body, frontmatter, emitLink, enrichNode, emitContribution, store) {
+  const scope = extractor.scope;
   return {
-    applicableExtractors,
-    applicableQualifiedIds,
-    cachedQualifiedIds,
-    missingExtractors,
-    fullCacheHit: opts.nodeHashCacheEligible && missingExtractors.length === 0
+    node,
+    body: scope === "frontmatter" ? "" : body,
+    frontmatter: scope === "body" ? {} : frontmatter,
+    emitLink,
+    enrichNode,
+    emitContribution,
+    ...store !== void 0 ? { store } : {}
   };
 }
-function cloneNodeAndReshapeLinks(opts) {
-  const node = { ...opts.priorNode, bytes: { ...opts.priorNode.bytes } };
-  if (opts.priorNode.tokens) node.tokens = { ...opts.priorNode.tokens };
-  const internalLinks = [];
-  const reusedLinks = opts.priorLinksByOriginating.get(opts.priorNode.path) ?? [];
-  for (const link of reusedLinks) {
-    const reshaped = reuseCachedLink(
-      link,
-      opts.shortIdToQualified,
-      opts.cachedQualifiedIds,
-      opts.applicableQualifiedIds
+function validateLink(extractor, link, emitter) {
+  if (!extractor.emitsLinkKinds.includes(link.kind)) {
+    const qualifiedId = `${extractor.pluginId}/${extractor.id}`;
+    emitter.emit(
+      makeEvent("extension.error", {
+        kind: "link-kind-not-declared",
+        extensionId: qualifiedId,
+        linkKind: link.kind,
+        declaredKinds: extractor.emitsLinkKinds,
+        link: { source: link.source, target: link.target, kind: link.kind },
+        message: tx(ORCHESTRATOR_TEXTS.extensionErrorLinkKindNotDeclared, {
+          extractorId: qualifiedId,
+          linkKind: link.kind,
+          declaredKinds: extractor.emitsLinkKinds.join(", ")
+        })
+      })
     );
-    if (reshaped) internalLinks.push(reshaped);
-  }
-  const frontmatterIssues = [];
-  const reusedFm = opts.priorFrontmatterIssuesByNode.get(opts.priorNode.path) ?? [];
-  for (const issue of reusedFm) {
-    frontmatterIssues.push({ ...issue, severity: opts.strict ? "error" : "warn" });
+    return null;
   }
-  return { node, internalLinks, frontmatterIssues };
+  const confidence = link.confidence ?? extractor.defaultConfidence;
+  return { ...link, confidence };
 }
-function reusePriorNode(opts) {
-  const base = cloneNodeAndReshapeLinks(opts);
-  const ranAt = Date.now();
-  const extractorRuns = [];
-  for (const qualified of opts.cachedQualifiedIds) {
-    extractorRuns.push({
-      nodePath: opts.priorNode.path,
-      extractorId: qualified,
-      bodyHashAtRun: opts.bodyHash,
-      ranAt
-    });
+function recomputeLinkCounts(nodes, links) {
+  const byPath2 = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    node.linksOutCount = 0;
+    node.linksInCount = 0;
+    byPath2.set(node.path, node);
   }
-  return { ...base, extractorRuns };
-}
-function buildFreshNodeAndValidateFrontmatter(opts) {
-  const node = buildNode({
-    path: opts.raw.path,
-    kind: opts.kind,
-    providerId: opts.provider.id,
-    frontmatterRaw: opts.raw.frontmatterRaw,
-    body: opts.raw.body,
-    frontmatter: opts.raw.frontmatter,
-    bodyHash: opts.bodyHash,
-    frontmatterHash: opts.frontmatterHash,
-    encoder: opts.encoder
-  });
-  const frontmatterIssues = [];
-  if (opts.raw.frontmatterRaw.length > 0) {
-    const fmIssue = validateFrontmatter(
-      opts.providerFrontmatter,
-      opts.provider,
-      opts.kind,
-      opts.raw.frontmatter,
-      opts.raw.path,
-      opts.strict
-    );
-    if (fmIssue) frontmatterIssues.push(fmIssue);
-  } else {
-    const malformed = detectMalformedFrontmatter(opts.raw.body, opts.raw.path, opts.strict);
-    if (malformed) frontmatterIssues.push(malformed);
+  for (const link of links) {
+    const source = byPath2.get(link.source);
+    if (source) source.linksOutCount += 1;
+    const target = byPath2.get(link.target);
+    if (target) target.linksInCount += 1;
   }
-  return { node, frontmatterIssues };
 }
-async function walkAndExtract(opts) {
-  const {
-    providers,
-    extractors,
-    roots,
-    ignoreFilter,
-    emitter,
-    encoder,
-    strict,
-    enableCache,
-    prior,
-    priorIndex,
-    priorExtractorRuns,
-    providerFrontmatter,
-    pluginStores
-  } = opts;
-  const { priorNodesByPath, priorLinksByOriginating, priorFrontmatterIssuesByNode } = priorIndex;
-  const nodes = [];
-  const internalLinks = [];
-  const externalLinks = [];
-  const cachedPaths = /* @__PURE__ */ new Set();
-  const frontmatterIssues = [];
-  const enrichmentBuffer = /* @__PURE__ */ new Map();
-  const contributionsBuffer = [];
-  const freshlyRunTuples = /* @__PURE__ */ new Set();
-  const extractorRuns = [];
-  const sidecarRoots = /* @__PURE__ */ new Map();
-  let filesWalked = 0;
-  let index = 0;
-  const walkOptions = ignoreFilter ? { ignoreFilter } : {};
-  const shortIdToQualified = /* @__PURE__ */ new Map();
-  for (const ex of extractors) {
-    const qualified = qualifiedExtensionId(ex.pluginId, ex.id);
-    const list = shortIdToQualified.get(ex.id);
-    if (list) list.push(qualified);
-    else shortIdToQualified.set(ex.id, [qualified]);
+function recomputeExternalRefsCount(nodes, externalLinks, cachedPaths) {
+  const byPath2 = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!cachedPaths.has(node.path)) node.externalRefsCount = 0;
+    byPath2.set(node.path, node);
   }
-  const claimedPaths = /* @__PURE__ */ new Set();
-  for (const provider of providers) {
-    for await (const raw of resolveProviderWalk(provider)(roots, walkOptions)) {
-      filesWalked += 1;
-      if (claimedPaths.has(raw.path)) continue;
-      const bodyHash = sha256(raw.body);
-      const frontmatterHash = sha256(canonicalFrontmatter(raw.frontmatter, raw.frontmatterRaw));
-      const priorNode = priorNodesByPath.get(raw.path);
-      const nodeHashCacheEligible = enableCache && prior !== null && priorNode !== void 0 && priorNode.bodyHash === bodyHash && priorNode.frontmatterHash === frontmatterHash;
-      const kind = provider.classify(raw.path, raw.frontmatter);
-      if (kind === null) {
-        continue;
-      }
-      claimedPaths.add(raw.path);
-      index += 1;
-      const cacheDecision = computeCacheDecision({
-        extractors,
-        kind,
-        nodePath: raw.path,
-        bodyHash,
-        nodeHashCacheEligible,
-        priorExtractorRuns
-      });
-      const {
-        applicableExtractors,
-        applicableQualifiedIds,
-        cachedQualifiedIds,
-        missingExtractors,
-        fullCacheHit
-      } = cacheDecision;
-      if (fullCacheHit && priorNode) {
-        const reused = reusePriorNode({
-          priorNode,
-          bodyHash,
-          strict,
-          cachedQualifiedIds,
-          applicableQualifiedIds,
-          shortIdToQualified,
-          priorLinksByOriginating,
-          priorFrontmatterIssuesByNode
-        });
-        const reusedSidecarIssues = resolveAndApplySidecar(
-          reused.node,
-          raw.path,
-          roots,
-          bodyHash,
-          frontmatterHash,
-          sidecarRoots
-        );
-        nodes.push(reused.node);
-        cachedPaths.add(reused.node.path);
-        for (const link of reused.internalLinks) internalLinks.push(link);
-        for (const issue of reused.frontmatterIssues) frontmatterIssues.push(issue);
-        for (const issue of reusedSidecarIssues) frontmatterIssues.push(issue);
-        for (const run of reused.extractorRuns) extractorRuns.push(run);
-        emitter.emit(makeEvent("scan.progress", { index, path: raw.path, kind, cached: true }));
-        continue;
-      }
-      let node;
-      const partialCacheHit = nodeHashCacheEligible && cachedQualifiedIds.size > 0 && priorNode !== void 0;
-      if (partialCacheHit && priorNode) {
-        const partial = cloneNodeAndReshapeLinks({
-          priorNode,
-          strict,
-          cachedQualifiedIds,
-          applicableQualifiedIds,
-          shortIdToQualified,
-          priorLinksByOriginating,
-          priorFrontmatterIssuesByNode
-        });
-        node = partial.node;
-        for (const link of partial.internalLinks) internalLinks.push(link);
-        for (const issue of partial.frontmatterIssues) frontmatterIssues.push(issue);
-        nodes.push(node);
-      } else {
-        const fresh = buildFreshNodeAndValidateFrontmatter({
-          raw,
-          kind,
-          provider,
-          bodyHash,
-          frontmatterHash,
-          encoder,
-          providerFrontmatter,
-          strict
-        });
-        node = fresh.node;
-        nodes.push(node);
-        for (const issue of fresh.frontmatterIssues) frontmatterIssues.push(issue);
-      }
-      const sidecarIssues = resolveAndApplySidecar(
-        node,
-        raw.path,
-        roots,
-        bodyHash,
-        frontmatterHash,
-        sidecarRoots
-      );
-      for (const issue of sidecarIssues) frontmatterIssues.push(issue);
-      emitter.emit(makeEvent("scan.progress", {
-        index,
-        path: raw.path,
-        kind,
-        cached: false,
-        ...partialCacheHit ? { partialCache: true } : {}
-      }));
-      const extractorsToRun = partialCacheHit ? missingExtractors : applicableExtractors;
-      for (const ex of extractorsToRun) {
-        freshlyRunTuples.add(`${ex.pluginId}/${ex.id}/${node.path}`);
-      }
-      const extractResult = await runExtractorsForNode({
-        extractors: extractorsToRun,
-        node,
-        body: raw.body,
-        frontmatter: raw.frontmatter,
-        bodyHash,
-        emitter,
-        ...pluginStores ? { pluginStores } : {}
-      });
-      for (const link of extractResult.internalLinks) internalLinks.push(link);
-      for (const link of extractResult.externalLinks) externalLinks.push(link);
-      for (const enr of extractResult.enrichments) {
-        enrichmentBuffer.set(`${enr.nodePath}\0${enr.extractorId}`, enr);
-      }
-      for (const c of extractResult.contributions) contributionsBuffer.push(c);
-      const ranAt = Date.now();
-      for (const ex of applicableExtractors) {
-        const qualified = qualifiedExtensionId(ex.pluginId, ex.id);
-        extractorRuns.push({
-          nodePath: node.path,
-          extractorId: qualified,
-          bodyHashAtRun: bodyHash,
-          ranAt
-        });
-      }
-    }
+  for (const link of externalLinks) {
+    const source = byPath2.get(link.source);
+    if (source && !cachedPaths.has(source.path)) source.externalRefsCount += 1;
   }
-  const orphanSidecars = discoverOrphanSidecars(roots);
-  return {
-    nodes,
-    internalLinks,
-    externalLinks,
-    cachedPaths,
-    frontmatterIssues,
-    filesWalked,
-    enrichments: [...enrichmentBuffer.values()],
-    extractorRuns,
-    contributions: contributionsBuffer,
-    freshlyRunTuples,
-    orphanSidecars,
-    sidecarRoots
-  };
 }
-function reuseCachedLink(link, shortIdToQualified, cachedQualifiedIds, applicableQualifiedIds) {
-  if (!Array.isArray(link.sources) || link.sources.length === 0) return null;
-  const cachedSources = [];
-  const obsoleteSources = [];
-  let hasMissing = false;
-  for (const source of link.sources) {
-    const candidates = shortIdToQualified.get(source);
-    if (!candidates || candidates.length === 0) {
-      obsoleteSources.push(source);
-      continue;
-    }
-    if (candidates.some((q) => cachedQualifiedIds.has(q))) {
-      cachedSources.push(source);
-      continue;
-    }
-    if (candidates.some((q) => applicableQualifiedIds.has(q))) {
-      hasMissing = true;
-      continue;
-    }
-    obsoleteSources.push(source);
-  }
-  if (hasMissing) return null;
-  if (cachedSources.length === 0) return null;
-  if (obsoleteSources.length === 0) return link;
-  return { ...link, sources: cachedSources };
+var EXTERNAL_URL_SCHEME_RE = /^[a-z][a-z0-9+\-.]+:/i;
+function isExternalUrlLink(link) {
+  return EXTERNAL_URL_SCHEME_RE.test(link.target);
 }
+
+// kernel/orchestrator/analyzers.ts
 async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, orphanJobFiles, referenceablePaths, cwd, emitter, hookDispatcher) {
   const issues = [];
   const contributions = [];
@@ -1681,12 +945,187 @@ async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sid
   }
   return { issues, contributions };
 }
+function validateIssue(analyzer, issue, emitter) {
+  const severity = issue.severity;
+  if (severity !== "error" && severity !== "warn" && severity !== "info") {
+    const qualifiedId = `${analyzer.pluginId}/${analyzer.id}`;
+    emitter.emit(
+      makeEvent("extension.error", {
+        kind: "issue-invalid-severity",
+        extensionId: qualifiedId,
+        severity,
+        issue: { analyzerId: issue.analyzerId || analyzer.id, message: issue.message, nodeIds: issue.nodeIds },
+        message: tx(ORCHESTRATOR_TEXTS.extensionErrorIssueInvalidSeverity, {
+          analyzerId: qualifiedId,
+          severity: JSON.stringify(severity)
+        })
+      })
+    );
+    return null;
+  }
+  return { ...issue, analyzerId: issue.analyzerId || analyzer.id };
+}
+
+// kernel/orchestrator/cache.ts
+function indexPriorSnapshot(prior) {
+  const priorNodesByPath = /* @__PURE__ */ new Map();
+  const priorNodePaths = /* @__PURE__ */ new Set();
+  const priorLinksByOriginating = /* @__PURE__ */ new Map();
+  const priorFrontmatterIssuesByNode = /* @__PURE__ */ new Map();
+  if (!prior) {
+    return { priorNodesByPath, priorNodePaths, priorLinksByOriginating, priorFrontmatterIssuesByNode };
+  }
+  indexPriorNodes(prior.nodes, priorNodesByPath, priorNodePaths);
+  indexPriorLinks(prior.links, priorNodePaths, priorLinksByOriginating);
+  indexPriorFrontmatterIssues(prior.issues, priorFrontmatterIssuesByNode);
+  return { priorNodesByPath, priorNodePaths, priorLinksByOriginating, priorFrontmatterIssuesByNode };
+}
+function indexPriorNodes(nodes, byPath2, paths) {
+  for (const node of nodes) {
+    byPath2.set(node.path, node);
+    paths.add(node.path);
+  }
+}
+function indexPriorLinks(links, priorNodePaths, byOriginating) {
+  for (const link of links) {
+    const key = originatingNodeOf(link, priorNodePaths);
+    const list = byOriginating.get(key);
+    if (list) list.push(link);
+    else byOriginating.set(key, [link]);
+  }
+}
+function indexPriorFrontmatterIssues(issues, byNode) {
+  for (const issue of issues) {
+    if (issue.analyzerId !== "frontmatter-invalid" && issue.analyzerId !== "frontmatter-malformed") continue;
+    if (issue.nodeIds.length !== 1) continue;
+    const path = issue.nodeIds[0];
+    const list = byNode.get(path);
+    if (list) list.push(issue);
+    else byNode.set(path, [issue]);
+  }
+}
 function originatingNodeOf(link, priorNodePaths) {
   if (link.kind === "supersedes" && !priorNodePaths.has(link.source)) {
     return link.target;
   }
   return link.source;
 }
+function computeCacheDecision(opts) {
+  const applicableExtractors = opts.extractors.filter(
+    (ex) => ex.applicableKinds === void 0 || ex.applicableKinds.includes(opts.kind)
+  );
+  const applicableQualifiedIds = new Set(
+    applicableExtractors.map((ex) => qualifiedExtensionId(ex.pluginId, ex.id))
+  );
+  const split = opts.priorExtractorRuns === void 0 ? splitLegacy(applicableExtractors, applicableQualifiedIds, opts.nodeHashCacheEligible) : splitFineGrained(applicableExtractors, opts);
+  return {
+    applicableExtractors,
+    applicableQualifiedIds,
+    cachedQualifiedIds: split.cachedQualifiedIds,
+    missingExtractors: split.missingExtractors,
+    fullCacheHit: opts.nodeHashCacheEligible && split.missingExtractors.length === 0
+  };
+}
+function splitLegacy(applicableExtractors, applicableQualifiedIds, nodeHashCacheEligible) {
+  const cachedQualifiedIds = /* @__PURE__ */ new Set();
+  const missingExtractors = [];
+  if (nodeHashCacheEligible) {
+    for (const id of applicableQualifiedIds) cachedQualifiedIds.add(id);
+  } else {
+    for (const ex of applicableExtractors) missingExtractors.push(ex);
+  }
+  return { cachedQualifiedIds, missingExtractors };
+}
+function splitFineGrained(applicableExtractors, opts) {
+  const cachedQualifiedIds = /* @__PURE__ */ new Set();
+  const missingExtractors = [];
+  const priorRunsForNode = opts.priorExtractorRuns.get(opts.nodePath) ?? /* @__PURE__ */ new Map();
+  for (const ex of applicableExtractors) {
+    const qualified = qualifiedExtensionId(ex.pluginId, ex.id);
+    const prior = priorRunsForNode.get(qualified);
+    if (opts.nodeHashCacheEligible && prior !== void 0 && prior.bodyHash === opts.bodyHash && prior.sidecarAnnotationsHash === opts.sidecarAnnotationsHash) {
+      cachedQualifiedIds.add(qualified);
+    } else {
+      missingExtractors.push(ex);
+    }
+  }
+  return { cachedQualifiedIds, missingExtractors };
+}
+function cloneNodeAndReshapeLinks(opts) {
+  const node = { ...opts.priorNode, bytes: { ...opts.priorNode.bytes } };
+  if (opts.priorNode.tokens) node.tokens = { ...opts.priorNode.tokens };
+  const internalLinks = [];
+  const reusedLinks = opts.priorLinksByOriginating.get(opts.priorNode.path) ?? [];
+  for (const link of reusedLinks) {
+    const reshaped = reuseCachedLink(
+      link,
+      opts.shortIdToQualified,
+      opts.cachedQualifiedIds,
+      opts.applicableQualifiedIds
+    );
+    if (reshaped) internalLinks.push(reshaped);
+  }
+  const frontmatterIssues = [];
+  const reusedFm = opts.priorFrontmatterIssuesByNode.get(opts.priorNode.path) ?? [];
+  for (const issue of reusedFm) {
+    frontmatterIssues.push({ ...issue, severity: opts.strict ? "error" : "warn" });
+  }
+  return { node, internalLinks, frontmatterIssues };
+}
+function reusePriorNode(opts) {
+  const base = cloneNodeAndReshapeLinks(opts);
+  const ranAt = Date.now();
+  const extractorRuns = [];
+  for (const qualified of opts.cachedQualifiedIds) {
+    extractorRuns.push({
+      nodePath: opts.priorNode.path,
+      extractorId: qualified,
+      bodyHashAtRun: opts.bodyHash,
+      ranAt,
+      sidecarAnnotationsHashAtRun: opts.sidecarAnnotationsHash
+    });
+  }
+  return { ...base, extractorRuns };
+}
+function reuseCachedLink(link, shortIdToQualified, cachedQualifiedIds, applicableQualifiedIds) {
+  if (!Array.isArray(link.sources) || link.sources.length === 0) return null;
+  const partition = partitionLinkSources(
+    link.sources,
+    shortIdToQualified,
+    cachedQualifiedIds,
+    applicableQualifiedIds
+  );
+  if (partition.hasMissing) return null;
+  if (partition.cached.length === 0) return null;
+  if (partition.obsolete.length === 0) return link;
+  return { ...link, sources: partition.cached };
+}
+function partitionLinkSources(sources, shortIdToQualified, cachedQualifiedIds, applicableQualifiedIds) {
+  const cached = [];
+  const obsolete = [];
+  let hasMissing = false;
+  for (const source of sources) {
+    const category = classifyLinkSource(
+      source,
+      shortIdToQualified,
+      cachedQualifiedIds,
+      applicableQualifiedIds
+    );
+    if (category === "cached") cached.push(source);
+    else if (category === "missing") hasMissing = true;
+    else obsolete.push(source);
+  }
+  return { cached, obsolete, hasMissing };
+}
+function classifyLinkSource(source, shortIdToQualified, cachedQualifiedIds, applicableQualifiedIds) {
+  const candidates = shortIdToQualified.get(source);
+  if (!candidates || candidates.length === 0) return "obsolete";
+  if (candidates.some((q) => cachedQualifiedIds.has(q))) return "cached";
+  if (candidates.some((q) => applicableQualifiedIds.has(q))) return "missing";
+  return "obsolete";
+}
+
+// kernel/orchestrator/renames.ts
 function findHighConfidenceRenames(opts) {
   const ops = [];
   for (const fromPath of opts.deletedPaths) {
@@ -1811,148 +1250,389 @@ function detectRenamesAndOrphans(prior, current, issues) {
   flagOrphans({ deletedPaths, claimedDeleted, issues });
   return ops;
 }
-var EXTERNAL_URL_SCHEME_RE = /^[a-z][a-z0-9+\-.]+:/i;
-function isExternalUrlLink(link) {
-  return EXTERNAL_URL_SCHEME_RE.test(link.target);
-}
-function buildNode(args) {
-  const bytesFrontmatter = Buffer.byteLength(args.frontmatterRaw, "utf8");
-  const bytesBody = Buffer.byteLength(args.body, "utf8");
-  const node = {
-    path: args.path,
-    kind: args.kind,
-    provider: args.providerId,
-    bodyHash: args.bodyHash,
-    frontmatterHash: args.frontmatterHash,
-    bytes: {
-      frontmatter: bytesFrontmatter,
-      body: bytesBody,
-      total: bytesFrontmatter + bytesBody
-    },
-    linksOutCount: 0,
-    linksInCount: 0,
-    externalRefsCount: 0,
-    frontmatter: args.frontmatter
-  };
-  if (args.encoder) {
-    node.tokens = countTokens(args.encoder, args.frontmatterRaw, args.body);
-  }
-  return node;
-}
-function countTokens(encoder, frontmatterRaw, body) {
-  const frontmatter = frontmatterRaw.length > 0 ? encoder.encode(frontmatterRaw).length : 0;
-  const bodyTokens = body.length > 0 ? encoder.encode(body).length : 0;
-  return { frontmatter, body: bodyTokens, total: frontmatter + bodyTokens };
-}
-function sha256(input) {
-  return createHash("sha256").update(input, "utf8").digest("hex");
-}
-function canonicalFrontmatter(parsed, raw) {
-  const hasParsedKeys = Object.keys(parsed).length > 0;
-  const hasRawText = raw.length > 0;
-  if (!hasParsedKeys && hasRawText) {
-    return raw;
+
+// kernel/scan/walk-content.ts
+import { readFile, readdir, stat } from "fs/promises";
+import { join as join2, relative as relative2, sep } from "path";
+
+// kernel/scan/ignore.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, resolve as resolve5 } from "path";
+import { fileURLToPath } from "url";
+import ignoreFactory from "ignore";
+function buildIgnoreFilter(opts = {}) {
+  const ig = ignoreFactory();
+  if (opts.includeDefaults !== false) {
+    ig.add(loadDefaultsText());
   }
-  return yaml4.dump(parsed, {
-    sortKeys: true,
-    lineWidth: -1,
-    noRefs: true,
-    noCompatMode: true
-  });
-}
-function resolveAndApplySidecar(node, relativePath, roots, liveBodyHash, liveFrontmatterHash, sidecarRoots) {
-  const issues = [];
-  const mdAbs = resolveAbsoluteMdPath(relativePath, roots);
-  if (mdAbs === null) {
-    node.sidecar = { present: false };
-    return issues;
+  if (opts.configIgnore && opts.configIgnore.length > 0) {
+    ig.add(opts.configIgnore);
   }
-  const result = readSidecarFor(mdAbs);
-  if (!result.present) {
-    node.sidecar = { present: false };
-    return issues;
+  if (opts.ignoreFileText && opts.ignoreFileText.length > 0) {
+    ig.add(opts.ignoreFileText);
   }
-  if (result.parsed === null) {
-    node.sidecar = { present: true, status: null, annotations: null, root: null };
-    for (const parseIssue of result.issues) {
-      issues.push({
-        analyzerId: "invalid-sidecar",
-        severity: "warn",
-        nodeIds: [node.path],
-        message: parseIssue.message,
-        data: { sidecarPath: relativePathFromRoots(mdAbs, roots) }
-      });
+  return {
+    ignores(relativePath) {
+      if (relativePath === "" || relativePath === "." || relativePath === "./") {
+        return false;
+      }
+      const normalised = relativePath.replace(/^\.\//, "").replace(/\\/g, "/").replace(/^\//, "");
+      if (normalised === "") return false;
+      return ig.ignores(normalised);
     }
-    return issues;
-  }
-  const status = computeDriftStatus({
-    storedBodyHash: result.parsed.identityBodyHash,
-    storedFrontmatterHash: result.parsed.identityFrontmatterHash,
-    liveBodyHash,
-    liveFrontmatterHash
-  });
-  node.sidecar = {
-    present: true,
-    status,
-    annotations: result.parsed.annotations,
-    root: result.parsed.raw
   };
-  sidecarRoots.set(node.path, result.parsed.raw);
-  return issues;
 }
-function resolveAbsoluteMdPath(relativePath, roots) {
-  if (isAbsolute2(relativePath)) {
-    return existsSync6(relativePath) ? relativePath : null;
-  }
-  for (const root of roots) {
-    const candidate = resolvePath(root, relativePath);
-    if (existsSync6(candidate)) return candidate;
-  }
-  return null;
+var cachedDefaults = null;
+function loadDefaultsText() {
+  if (cachedDefaults !== null) return cachedDefaults;
+  cachedDefaults = readDefaultsFromDisk();
+  return cachedDefaults;
 }
-function relativePathFromRoots(absolutePath, roots) {
-  for (const root of roots) {
-    const abs = resolvePath(root);
-    if (absolutePath.startsWith(`${abs}/`) || absolutePath.startsWith(`${abs}\\`)) {
-      return absolutePath.slice(abs.length + 1).split(/[\\/]/).join("/");
+function readDefaultsFromDisk() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve5(here, "../../config/defaults/skillmapignore"),
+    // src/kernel/scan/ → src/config/defaults/
+    resolve5(here, "../config/defaults/skillmapignore"),
+    // dist/cli.js → dist/config/defaults/ (siblings)
+    resolve5(here, "config/defaults/skillmapignore")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) {
+      try {
+        return readFileSync4(candidate, "utf8");
+      } catch {
+      }
     }
   }
-  return absolutePath;
+  return "";
 }
-function buildExtractorContext(extractor, node, body, frontmatter, emitLink, enrichNode, emitContribution, store) {
-  const scope = extractor.scope;
-  return {
-    node,
-    body: scope === "frontmatter" ? "" : body,
-    frontmatter: scope === "body" ? {} : frontmatter,
-    emitLink,
-    enrichNode,
-    emitContribution,
-    ...store !== void 0 ? { store } : {}
+
+// built-in-plugins/parsers/frontmatter-yaml/index.ts
+import yaml from "js-yaml";
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var FORBIDDEN_FRONTMATTER_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var frontmatterYamlParser = {
+  id: "frontmatter-yaml",
+  parse(raw, _path) {
+    const match = FRONTMATTER_RE.exec(raw);
+    if (!match) return { frontmatterRaw: "", frontmatter: {}, body: raw };
+    const frontmatterRaw = match[1];
+    const body = match[2];
+    const parsed = {};
+    try {
+      const doc = yaml.load(frontmatterRaw, { schema: yaml.JSON_SCHEMA });
+      if (doc && typeof doc === "object" && !Array.isArray(doc)) {
+        for (const [k, v] of Object.entries(doc)) {
+          if (FORBIDDEN_FRONTMATTER_KEYS.has(k)) continue;
+          parsed[k] = v;
+        }
+      }
+    } catch {
+    }
+    return { frontmatterRaw, frontmatter: parsed, body };
+  }
+};
+
+// built-in-plugins/parsers/plain/index.ts
+var plainParser = {
+  id: "plain",
+  parse(raw, _path) {
+    return { frontmatter: {}, frontmatterRaw: "", body: raw };
+  }
+};
+
+// kernel/scan/parsers/index.ts
+var REGISTRY = /* @__PURE__ */ new Map([
+  [frontmatterYamlParser.id, frontmatterYamlParser],
+  [plainParser.id, plainParser]
+]);
+var FROZEN_IDS = new Set(REGISTRY.keys());
+function getParser(id) {
+  return REGISTRY.get(id);
+}
+
+// kernel/scan/walk-content.ts
+var UnknownParserError = class extends Error {
+  constructor(parserId) {
+    super(`Unknown parser id '${parserId}'. Built-in parsers: 'frontmatter-yaml', 'plain'.`);
+    this.name = "UnknownParserError";
+  }
+};
+async function* walkContent(roots, options) {
+  const parser = getParser(options.parser);
+  if (!parser) throw new UnknownParserError(options.parser);
+  const filter = options.ignoreFilter ?? buildIgnoreFilter();
+  const extensions = options.extensions;
+  for (const root of roots) {
+    for await (const file of walkRoot(root, root, filter, extensions)) {
+      const relPath = relative2(root, file).split(sep).join("/");
+      let raw;
+      try {
+        raw = await readFile(file, "utf8");
+      } catch {
+        continue;
+      }
+      const parsed = parser.parse(raw, relPath);
+      yield {
+        path: relPath,
+        body: parsed.body,
+        frontmatterRaw: parsed.frontmatterRaw,
+        frontmatter: parsed.frontmatter
+      };
+    }
+  }
+}
+async function* walkRoot(root, current, filter, extensions) {
+  let entries;
+  try {
+    entries = await readdir(current, { withFileTypes: true, encoding: "utf8" });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const name = entry.name;
+    const full = join2(current, name);
+    const rel = relative2(root, full).split(sep).join("/");
+    if (filter.ignores(rel)) continue;
+    if (entry.isSymbolicLink()) continue;
+    if (entry.isDirectory()) {
+      yield* walkRoot(root, full, filter, extensions);
+    } else if (entry.isFile() && hasMatchingExtension(name, extensions)) {
+      try {
+        const s = await stat(full);
+        if (s.isFile()) yield full;
+      } catch {
+      }
+    }
+  }
+}
+function hasMatchingExtension(name, extensions) {
+  for (const ext of extensions) {
+    if (name.endsWith(ext)) return true;
+  }
+  return false;
+}
+
+// kernel/extensions/provider.ts
+var DEFAULT_READ_CONFIG = Object.freeze({
+  extensions: Object.freeze([".md"]),
+  parser: "frontmatter-yaml"
+});
+function resolveProviderWalk(provider) {
+  if (provider.walk) {
+    const walk2 = provider.walk.bind(provider);
+    return walk2;
+  }
+  const read = provider.read ?? DEFAULT_READ_CONFIG;
+  return (roots, options) => {
+    const walkOptions = {
+      extensions: read.extensions,
+      parser: read.parser
+    };
+    if (options?.ignoreFilter) walkOptions.ignoreFilter = options.ignoreFilter;
+    return walkContent(roots, walkOptions);
   };
 }
-function validateLink(extractor, link, emitter) {
-  if (!extractor.emitsLinkKinds.includes(link.kind)) {
-    const qualifiedId = `${extractor.pluginId}/${extractor.id}`;
-    emitter.emit(
-      makeEvent("extension.error", {
-        kind: "link-kind-not-declared",
-        extensionId: qualifiedId,
-        linkKind: link.kind,
-        declaredKinds: extractor.emitsLinkKinds,
-        link: { source: link.source, target: link.target, kind: link.kind },
-        message: tx(ORCHESTRATOR_TEXTS.extensionErrorLinkKindNotDeclared, {
-          extractorId: qualifiedId,
-          linkKind: link.kind,
-          declaredKinds: extractor.emitsLinkKinds.join(", ")
-        })
-      })
+
+// kernel/sidecar/parse.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname3, resolve as resolve6 } 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 (!existsSync3(sidecarPath)) {
+    return { parsed: null, present: false, issues: [] };
+  }
+  let raw;
+  try {
+    raw = readFileSync5(sidecarPath, "utf8");
+  } catch (err) {
+    return {
+      parsed: null,
+      present: true,
+      issues: [{ message: `cannot read ${sidecarPath}: ${err.message}` }]
+    };
+  }
+  let parsedYaml;
+  try {
+    parsedYaml = yaml2.load(raw);
+  } catch (err) {
+    return {
+      parsed: null,
+      present: true,
+      issues: [{ message: `malformed YAML in ${sidecarPath}: ${err.message}` }]
+    };
+  }
+  if (!isPlainObject(parsedYaml)) {
+    return {
+      parsed: null,
+      present: true,
+      issues: [{ message: `sidecar root must be a YAML mapping at ${sidecarPath}` }]
+    };
+  }
+  const sidecarValidator = getSidecarValidator();
+  if (!sidecarValidator(parsedYaml)) {
+    const errors = (sidecarValidator.errors ?? []).map((e) => `${e.instancePath || "(root)"} ${e.message ?? e.keyword}`).join("; ");
+    return {
+      parsed: null,
+      present: true,
+      issues: [{ message: `sidecar schema validation failed at ${sidecarPath}: ${errors}` }]
+    };
+  }
+  const root = parsedYaml;
+  const identityBlock = root["identity"];
+  const annotationsRaw = root["annotations"];
+  const annotations = isPlainObject(annotationsRaw) ? Object.keys(annotationsRaw).length === 0 ? null : annotationsRaw : null;
+  return {
+    parsed: {
+      filePath: sidecarPath,
+      identityBodyHash: String(identityBlock["bodyHash"]),
+      identityFrontmatterHash: String(identityBlock["frontmatterHash"]),
+      identityPath: String(identityBlock["path"]),
+      annotations,
+      raw: root
+    },
+    present: true,
+    issues: []
+  };
+}
+function sidecarPathFor(mdAbsolutePath) {
+  if (mdAbsolutePath.endsWith(".md")) {
+    return `${mdAbsolutePath.slice(0, -".md".length)}.sm`;
+  }
+  return `${mdAbsolutePath}.sm`;
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var cachedSidecarValidator = null;
+function getSidecarValidator() {
+  if (cachedSidecarValidator) return cachedSidecarValidator;
+  const ajv = new Ajv20204({ strict: false, allErrors: true, allowUnionTypes: true });
+  applyAjvFormats(ajv);
+  const specRoot = resolveSpecRoot2();
+  const annotationsSchema = JSON.parse(
+    readFileSync5(resolve6(specRoot, "schemas/annotations.schema.json"), "utf8")
+  );
+  const sidecarSchema = JSON.parse(
+    readFileSync5(resolve6(specRoot, "schemas/sidecar.schema.json"), "utf8")
+  );
+  ajv.addSchema(annotationsSchema);
+  cachedSidecarValidator = ajv.compile(sidecarSchema);
+  return cachedSidecarValidator;
+}
+function resolveSpecRoot2() {
+  const require2 = createRequire3(import.meta.url);
+  try {
+    const indexPath = require2.resolve("@skill-map/spec/index.json");
+    return dirname3(indexPath);
+  } catch {
+    throw new Error(
+      "@skill-map/spec not resolvable \u2014 sidecar reader cannot load schemas."
     );
-    return null;
   }
-  const confidence = link.confidence ?? extractor.defaultConfidence;
-  return { ...link, confidence };
 }
+
+// kernel/sidecar/drift.ts
+function computeDriftStatus(args) {
+  const bodyDrift = args.storedBodyHash !== args.liveBodyHash;
+  const fmDrift = args.storedFrontmatterHash !== args.liveFrontmatterHash;
+  if (bodyDrift && fmDrift) return "stale-both";
+  if (bodyDrift) return "stale-body";
+  if (fmDrift) return "stale-frontmatter";
+  return "fresh";
+}
+
+// kernel/sidecar/discover-orphans.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join3, relative as relative3, sep as sep2 } from "path";
+function discoverOrphanSidecars(roots, shouldSkip) {
+  const out = [];
+  for (const root of roots) {
+    walk(root, root, shouldSkip ?? (() => false), out);
+  }
+  return out;
+}
+function walk(root, current, shouldSkip, out) {
+  let entries;
+  try {
+    entries = readdirSync2(current, { withFileTypes: true, encoding: "utf8" });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = join3(current, entry.name);
+    const rel = relative3(root, full).split(sep2).join("/");
+    if (shouldSkip(rel)) continue;
+    if (entry.isSymbolicLink()) continue;
+    if (entry.isDirectory()) {
+      walk(root, full, shouldSkip, out);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith(".sm")) continue;
+    const expectedMd = `${full.slice(0, -".sm".length)}.md`;
+    if (existsSync4(expectedMd) && safeIsFile(expectedMd)) continue;
+    out.push({ sidecarPath: full, relativePath: rel, expectedMdPath: expectedMd });
+  }
+}
+function safeIsFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// kernel/sidecar/store.ts
+import { existsSync as existsSync7, readFileSync as readFileSync8, renameSync as renameSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
+import { dirname as dirname5, 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/helper.ts
+import { isAbsolute as isAbsolute2, resolve as resolve8 } from "path";
+
+// kernel/config/loader.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
+
+// kernel/util/skill-map-paths.ts
+import { join as join5 } from "path";
+
+// core/paths/db-path.ts
+import { join as join4, 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}`
+];
+
+// core/config/atomic-write.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync,
+  readFileSync as readFileSync7,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname as dirname4 } from "path";
+
+// kernel/orchestrator/node-build.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync8 } from "fs";
+import { isAbsolute as isAbsolute3, resolve as resolvePath } from "path";
+import "js-tiktoken/lite";
+import yaml4 from "js-yaml";
+
+// kernel/orchestrator/frontmatter.ts
 function validateFrontmatter(providerFrontmatter, provider, kind, frontmatter, path, strict) {
   const result = providerFrontmatter.validate(provider, kind, frontmatter);
   if (result.ok) return null;
@@ -2002,50 +1682,160 @@ function malformedMessage(hint, path) {
       return tx(ORCHESTRATOR_TEXTS.frontmatterMalformedMissingClose, { path });
   }
 }
-function validateIssue(analyzer, issue, emitter) {
-  const severity = issue.severity;
-  if (severity !== "error" && severity !== "warn" && severity !== "info") {
-    const qualifiedId = `${analyzer.pluginId}/${analyzer.id}`;
-    emitter.emit(
-      makeEvent("extension.error", {
-        kind: "issue-invalid-severity",
-        extensionId: qualifiedId,
-        severity,
-        issue: { analyzerId: issue.analyzerId || analyzer.id, message: issue.message, nodeIds: issue.nodeIds },
-        message: tx(ORCHESTRATOR_TEXTS.extensionErrorIssueInvalidSeverity, {
-          analyzerId: qualifiedId,
-          severity: JSON.stringify(severity)
-        })
-      })
-    );
-    return null;
+
+// kernel/orchestrator/node-build.ts
+function buildNode(args) {
+  const bytesFrontmatter = Buffer.byteLength(args.frontmatterRaw, "utf8");
+  const bytesBody = Buffer.byteLength(args.body, "utf8");
+  const node = {
+    path: args.path,
+    kind: args.kind,
+    provider: args.providerId,
+    bodyHash: args.bodyHash,
+    frontmatterHash: args.frontmatterHash,
+    bytes: {
+      frontmatter: bytesFrontmatter,
+      body: bytesBody,
+      total: bytesFrontmatter + bytesBody
+    },
+    linksOutCount: 0,
+    linksInCount: 0,
+    externalRefsCount: 0,
+    frontmatter: args.frontmatter
+  };
+  if (args.encoder) {
+    node.tokens = countTokens(args.encoder, args.frontmatterRaw, args.body);
+  }
+  return node;
+}
+function countTokens(encoder, frontmatterRaw, body) {
+  const frontmatter = frontmatterRaw.length > 0 ? encoder.encode(frontmatterRaw).length : 0;
+  const bodyTokens = body.length > 0 ? encoder.encode(body).length : 0;
+  return { frontmatter, body: bodyTokens, total: frontmatter + bodyTokens };
+}
+function sha256(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+function canonicalFrontmatter(parsed, raw) {
+  const hasParsedKeys = Object.keys(parsed).length > 0;
+  const hasRawText = raw.length > 0;
+  if (!hasParsedKeys && hasRawText) {
+    return raw;
+  }
+  return yaml4.dump(parsed, {
+    sortKeys: true,
+    lineWidth: -1,
+    noRefs: true,
+    noCompatMode: true
+  });
+}
+function canonicalSidecarAnnotations(annotations) {
+  if (!annotations || typeof annotations !== "object" || Array.isArray(annotations)) {
+    return yaml4.dump({}, { sortKeys: true, lineWidth: -1, noRefs: true, noCompatMode: true });
+  }
+  return yaml4.dump(annotations, {
+    sortKeys: true,
+    lineWidth: -1,
+    noRefs: true,
+    noCompatMode: true
+  });
+}
+function resolveSidecarOverlay(relativePath, nodePathForIssue, roots, liveBodyHash, liveFrontmatterHash) {
+  const issues = [];
+  const mdAbs = resolveAbsoluteMdPath(relativePath, roots);
+  if (mdAbs === null) {
+    return { overlay: { present: false }, issues, parsedRoot: null };
+  }
+  const result = readSidecarFor(mdAbs);
+  if (!result.present) {
+    return { overlay: { present: false }, issues, parsedRoot: null };
+  }
+  if (result.parsed === null) {
+    for (const parseIssue of result.issues) {
+      issues.push({
+        analyzerId: "invalid-sidecar",
+        severity: "warn",
+        nodeIds: [nodePathForIssue],
+        message: parseIssue.message,
+        data: { sidecarPath: relativePathFromRoots(mdAbs, roots) }
+      });
+    }
+    return {
+      overlay: { present: true, status: null, annotations: null, root: null },
+      issues,
+      parsedRoot: null
+    };
   }
-  return { ...issue, analyzerId: issue.analyzerId || analyzer.id };
+  const status = computeDriftStatus({
+    storedBodyHash: result.parsed.identityBodyHash,
+    storedFrontmatterHash: result.parsed.identityFrontmatterHash,
+    liveBodyHash,
+    liveFrontmatterHash
+  });
+  return {
+    // R15 closure (2026-05-07) — surface the full parsed root on the
+    // overlay so BFF consumers (UI inspector audit / plugin-contributions
+    // / debug panels) can read `for.*`, `audit.*`, `settings.*`, and
+    // plugin-namespaced sub-keys without re-reading the file. The
+    // `annotations` field above stays — it duplicates `root.annotations`
+    // by design so existing consumers keep working unchanged.
+    overlay: {
+      present: true,
+      status,
+      annotations: result.parsed.annotations,
+      root: result.parsed.raw
+    },
+    issues,
+    parsedRoot: result.parsed.raw
+  };
 }
-function recomputeLinkCounts(nodes, links) {
-  const byPath2 = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    node.linksOutCount = 0;
-    node.linksInCount = 0;
-    byPath2.set(node.path, node);
+function resolveAbsoluteMdPath(relativePath, roots) {
+  if (isAbsolute3(relativePath)) {
+    return existsSync8(relativePath) ? relativePath : null;
   }
-  for (const link of links) {
-    const source = byPath2.get(link.source);
-    if (source) source.linksOutCount += 1;
-    const target = byPath2.get(link.target);
-    if (target) target.linksInCount += 1;
+  for (const root of roots) {
+    const candidate = resolvePath(root, relativePath);
+    if (existsSync8(candidate)) return candidate;
   }
+  return null;
 }
-function recomputeExternalRefsCount(nodes, externalLinks, cachedPaths) {
-  const byPath2 = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    if (!cachedPaths.has(node.path)) node.externalRefsCount = 0;
-    byPath2.set(node.path, node);
+function relativePathFromRoots(absolutePath, roots) {
+  for (const root of roots) {
+    const abs = resolvePath(root);
+    if (absolutePath.startsWith(`${abs}/`) || absolutePath.startsWith(`${abs}\\`)) {
+      return absolutePath.slice(abs.length + 1).split(/[\\/]/).join("/");
+    }
   }
-  for (const link of externalLinks) {
-    const source = byPath2.get(link.source);
-    if (source && !cachedPaths.has(source.path)) source.externalRefsCount += 1;
+  return absolutePath;
+}
+function buildFreshNodeAndValidateFrontmatter(opts) {
+  const node = buildNode({
+    path: opts.raw.path,
+    kind: opts.kind,
+    providerId: opts.provider.id,
+    frontmatterRaw: opts.raw.frontmatterRaw,
+    body: opts.raw.body,
+    frontmatter: opts.raw.frontmatter,
+    bodyHash: opts.bodyHash,
+    frontmatterHash: opts.frontmatterHash,
+    encoder: opts.encoder
+  });
+  const frontmatterIssues = [];
+  if (opts.raw.frontmatterRaw.length > 0) {
+    const fmIssue = validateFrontmatter(
+      opts.providerFrontmatter,
+      opts.provider,
+      opts.kind,
+      opts.raw.frontmatter,
+      opts.raw.path,
+      opts.strict
+    );
+    if (fmIssue) frontmatterIssues.push(fmIssue);
+  } else {
+    const malformed = detectMalformedFrontmatter(opts.raw.body, opts.raw.path, opts.strict);
+    if (malformed) frontmatterIssues.push(malformed);
   }
+  return { node, frontmatterIssues };
 }
 function mergeNodeWithEnrichments(node, enrichments, opts = {}) {
   const includeStale = opts.includeStale === true;
@@ -2065,11 +1855,400 @@ function assignSafe(target, source) {
   }
 }
 
+// kernel/orchestrator/walk.ts
+async function walkAndExtract(opts) {
+  const accum = createWalkAccumulators();
+  const wctx = buildWalkContext(opts);
+  const claimedPaths = /* @__PURE__ */ new Set();
+  const walkOptions = opts.ignoreFilter ? { ignoreFilter: opts.ignoreFilter } : {};
+  let filesWalked = 0;
+  let index = 0;
+  for (const provider of opts.providers) {
+    for await (const raw of resolveProviderWalk(provider)(opts.roots, walkOptions)) {
+      filesWalked += 1;
+      if (claimedPaths.has(raw.path)) continue;
+      const advanced = await processRawNode(raw, provider, wctx, accum, claimedPaths, index + 1);
+      if (advanced) index += 1;
+    }
+  }
+  const orphanSidecars = discoverOrphanSidecars(opts.roots);
+  return {
+    nodes: accum.nodes,
+    internalLinks: accum.internalLinks,
+    externalLinks: accum.externalLinks,
+    cachedPaths: accum.cachedPaths,
+    frontmatterIssues: accum.frontmatterIssues,
+    filesWalked,
+    enrichments: [...accum.enrichmentBuffer.values()],
+    extractorRuns: accum.extractorRuns,
+    contributions: accum.contributionsBuffer,
+    freshlyRunTuples: accum.freshlyRunTuples,
+    orphanSidecars,
+    sidecarRoots: accum.sidecarRoots
+  };
+}
+function createWalkAccumulators() {
+  return {
+    nodes: [],
+    internalLinks: [],
+    externalLinks: [],
+    cachedPaths: /* @__PURE__ */ new Set(),
+    frontmatterIssues: [],
+    enrichmentBuffer: /* @__PURE__ */ new Map(),
+    contributionsBuffer: [],
+    freshlyRunTuples: /* @__PURE__ */ new Set(),
+    extractorRuns: [],
+    sidecarRoots: /* @__PURE__ */ new Map()
+  };
+}
+function buildWalkContext(opts) {
+  const { priorNodesByPath, priorLinksByOriginating, priorFrontmatterIssuesByNode } = opts.priorIndex;
+  const shortIdToQualified = /* @__PURE__ */ new Map();
+  for (const ex of opts.extractors) {
+    const qualified = qualifiedExtensionId(ex.pluginId, ex.id);
+    const list = shortIdToQualified.get(ex.id);
+    if (list) list.push(qualified);
+    else shortIdToQualified.set(ex.id, [qualified]);
+  }
+  return { opts, priorNodesByPath, priorLinksByOriginating, priorFrontmatterIssuesByNode, shortIdToQualified };
+}
+async function processRawNode(raw, provider, wctx, accum, claimedPaths, nextIndex) {
+  const bodyHash = sha256(raw.body);
+  const frontmatterHash = sha256(canonicalFrontmatter(raw.frontmatter, raw.frontmatterRaw));
+  const kind = provider.classify(raw.path, raw.frontmatter);
+  if (kind === null) {
+    return false;
+  }
+  claimedPaths.add(raw.path);
+  const priorNode = wctx.priorNodesByPath.get(raw.path);
+  const nodeHashCacheEligible = wctx.opts.enableCache && wctx.opts.prior !== null && priorNode !== void 0 && priorNode.bodyHash === bodyHash && priorNode.frontmatterHash === frontmatterHash;
+  const sidecarResolution = resolveSidecarOverlay(
+    raw.path,
+    raw.path,
+    wctx.opts.roots,
+    bodyHash,
+    frontmatterHash
+  );
+  const sidecarAnnotationsHash = sha256(
+    canonicalSidecarAnnotations(sidecarResolution.overlay.annotations)
+  );
+  const cacheDecision = computeCacheDecision({
+    extractors: wctx.opts.extractors,
+    kind,
+    nodePath: raw.path,
+    bodyHash,
+    sidecarAnnotationsHash,
+    nodeHashCacheEligible,
+    priorExtractorRuns: wctx.opts.priorExtractorRuns
+  });
+  const ctx = {
+    raw,
+    provider,
+    kind,
+    bodyHash,
+    frontmatterHash,
+    sidecarResolution,
+    sidecarAnnotationsHash,
+    nodeHashCacheEligible,
+    cacheDecision,
+    priorNode,
+    index: nextIndex
+  };
+  if (cacheDecision.fullCacheHit && priorNode) {
+    applyFullCacheHit(ctx, wctx, accum);
+  } else {
+    await applyExtractPath(ctx, wctx, accum);
+  }
+  return true;
+}
+function attachSidecar(node, resolution, sidecarRoots) {
+  node.sidecar = resolution.overlay;
+  if (resolution.parsedRoot !== null) {
+    sidecarRoots.set(node.path, resolution.parsedRoot);
+  }
+  return resolution.issues.map(
+    (i) => i.nodeIds.length > 0 ? i : { ...i, nodeIds: [node.path] }
+  );
+}
+function applyFullCacheHit(ctx, wctx, accum) {
+  const reused = reusePriorNode({
+    priorNode: ctx.priorNode,
+    bodyHash: ctx.bodyHash,
+    sidecarAnnotationsHash: ctx.sidecarAnnotationsHash,
+    strict: wctx.opts.strict,
+    cachedQualifiedIds: ctx.cacheDecision.cachedQualifiedIds,
+    applicableQualifiedIds: ctx.cacheDecision.applicableQualifiedIds,
+    shortIdToQualified: wctx.shortIdToQualified,
+    priorLinksByOriginating: wctx.priorLinksByOriginating,
+    priorFrontmatterIssuesByNode: wctx.priorFrontmatterIssuesByNode
+  });
+  const reusedSidecarIssues = attachSidecar(reused.node, ctx.sidecarResolution, accum.sidecarRoots);
+  accum.nodes.push(reused.node);
+  accum.cachedPaths.add(reused.node.path);
+  for (const link of reused.internalLinks) accum.internalLinks.push(link);
+  for (const issue of reused.frontmatterIssues) accum.frontmatterIssues.push(issue);
+  for (const issue of reusedSidecarIssues) accum.frontmatterIssues.push(issue);
+  for (const run of reused.extractorRuns) accum.extractorRuns.push(run);
+  wctx.opts.emitter.emit(makeEvent("scan.progress", {
+    index: ctx.index,
+    path: ctx.raw.path,
+    kind: ctx.kind,
+    cached: true
+  }));
+}
+async function applyExtractPath(ctx, wctx, accum) {
+  const node = buildOrReuseNode(ctx, wctx, accum);
+  const sidecarIssues = attachSidecar(node, ctx.sidecarResolution, accum.sidecarRoots);
+  for (const issue of sidecarIssues) accum.frontmatterIssues.push(issue);
+  const partialCacheHit = isPartialCacheHit(ctx);
+  emitExtractProgress(ctx, wctx, partialCacheHit);
+  const extractorsToRun = partialCacheHit ? ctx.cacheDecision.missingExtractors : ctx.cacheDecision.applicableExtractors;
+  recordFreshlyRunTuples(extractorsToRun, node.path, accum);
+  const extractResult = await runExtractorsForNode({
+    extractors: extractorsToRun,
+    node,
+    body: ctx.raw.body,
+    frontmatter: ctx.raw.frontmatter,
+    bodyHash: ctx.bodyHash,
+    emitter: wctx.opts.emitter,
+    ...wctx.opts.pluginStores ? { pluginStores: wctx.opts.pluginStores } : {}
+  });
+  mergeExtractResult(extractResult, accum);
+  recordExtractorRuns(node.path, ctx, accum);
+}
+function emitExtractProgress(ctx, wctx, partialCacheHit) {
+  wctx.opts.emitter.emit(makeEvent("scan.progress", {
+    index: ctx.index,
+    path: ctx.raw.path,
+    kind: ctx.kind,
+    cached: false,
+    ...partialCacheHit ? { partialCache: true } : {}
+  }));
+}
+function recordFreshlyRunTuples(extractors, nodePath, accum) {
+  for (const ex of extractors) {
+    accum.freshlyRunTuples.add(`${ex.pluginId}\0${ex.id}\0${nodePath}`);
+  }
+}
+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 enr of extractResult.enrichments) {
+    accum.enrichmentBuffer.set(`${enr.nodePath}\0${enr.extractorId}`, enr);
+  }
+  for (const c of extractResult.contributions) accum.contributionsBuffer.push(c);
+}
+function isPartialCacheHit(ctx) {
+  return ctx.nodeHashCacheEligible && ctx.cacheDecision.cachedQualifiedIds.size > 0 && ctx.priorNode !== void 0;
+}
+function buildOrReuseNode(ctx, wctx, accum) {
+  if (isPartialCacheHit(ctx) && ctx.priorNode) {
+    const partial = cloneNodeAndReshapeLinks({
+      priorNode: ctx.priorNode,
+      strict: wctx.opts.strict,
+      cachedQualifiedIds: ctx.cacheDecision.cachedQualifiedIds,
+      applicableQualifiedIds: ctx.cacheDecision.applicableQualifiedIds,
+      shortIdToQualified: wctx.shortIdToQualified,
+      priorLinksByOriginating: wctx.priorLinksByOriginating,
+      priorFrontmatterIssuesByNode: wctx.priorFrontmatterIssuesByNode
+    });
+    for (const link of partial.internalLinks) accum.internalLinks.push(link);
+    for (const issue of partial.frontmatterIssues) accum.frontmatterIssues.push(issue);
+    accum.nodes.push(partial.node);
+    return partial.node;
+  }
+  const fresh = buildFreshNodeAndValidateFrontmatter({
+    raw: ctx.raw,
+    kind: ctx.kind,
+    provider: ctx.provider,
+    bodyHash: ctx.bodyHash,
+    frontmatterHash: ctx.frontmatterHash,
+    encoder: wctx.opts.encoder,
+    providerFrontmatter: wctx.opts.providerFrontmatter,
+    strict: wctx.opts.strict
+  });
+  accum.nodes.push(fresh.node);
+  for (const issue of fresh.frontmatterIssues) accum.frontmatterIssues.push(issue);
+  return fresh.node;
+}
+function recordExtractorRuns(nodePath, ctx, accum) {
+  const ranAt = Date.now();
+  for (const ex of ctx.cacheDecision.applicableExtractors) {
+    accum.extractorRuns.push({
+      nodePath,
+      extractorId: qualifiedExtensionId(ex.pluginId, ex.id),
+      bodyHashAtRun: ctx.bodyHash,
+      ranAt,
+      sidecarAnnotationsHashAtRun: ctx.sidecarAnnotationsHash
+    });
+  }
+}
+
+// kernel/orchestrator/index.ts
+var SCANNED_BY = {
+  name: "skill-map",
+  version: package_default.version,
+  specVersion: resolveSpecVersionSafe()
+};
+function resolveSpecVersionSafe() {
+  try {
+    return installedSpecVersion();
+  } catch {
+    return "unknown";
+  }
+}
+async function runScanWithRenames(_kernel, options) {
+  return runScanInternal(_kernel, options);
+}
+async function runScan(_kernel, options) {
+  const { result } = await runScanInternal(_kernel, options);
+  return result;
+}
+async function runScanInternal(_kernel, options) {
+  validateRoots(options.roots);
+  const setup = buildScanSetup(options);
+  const { emitter, exts, hookDispatcher, encoder, prior, start } = setup;
+  const scanStartedEvent = makeEvent("scan.started", { roots: options.roots });
+  emitter.emit(scanStartedEvent);
+  await hookDispatcher.dispatch("scan.started", scanStartedEvent);
+  const walked = await walkAndExtract({
+    providers: exts.providers,
+    extractors: exts.extractors,
+    roots: options.roots,
+    ...options.ignoreFilter ? { ignoreFilter: options.ignoreFilter } : {},
+    emitter,
+    encoder,
+    strict: setup.strict,
+    enableCache: setup.enableCache,
+    prior,
+    priorIndex: setup.priorIndex,
+    priorExtractorRuns: setup.priorExtractorRuns,
+    providerFrontmatter: setup.providerFrontmatter,
+    pluginStores: options.pluginStores
+  });
+  recomputeLinkCounts(walked.nodes, walked.internalLinks);
+  recomputeExternalRefsCount(walked.nodes, walked.externalLinks, walked.cachedPaths);
+  await dispatchExtractorCompleted(exts.extractors, emitter, hookDispatcher);
+  const analyzerResult = await runAnalyzers(
+    exts.analyzers,
+    walked.nodes,
+    walked.internalLinks,
+    walked.orphanSidecars,
+    walked.sidecarRoots,
+    options.annotationContributions ?? [],
+    options.viewContributions ?? [],
+    options.orphanJobFiles ?? [],
+    options.referenceablePaths,
+    options.cwd,
+    emitter,
+    hookDispatcher
+  );
+  mergeAnalyzerEmissions(walked, analyzerResult, exts.analyzers);
+  const issues = analyzerResult.issues;
+  for (const issue of walked.frontmatterIssues) issues.push(issue);
+  const renameOps = prior ? detectRenamesAndOrphans(prior, walked.nodes, issues) : [];
+  const stats = buildScanStats(walked, issues, start);
+  const scanCompletedEvent = makeEvent("scan.completed", { stats });
+  emitter.emit(scanCompletedEvent);
+  await hookDispatcher.dispatch("scan.completed", scanCompletedEvent);
+  return buildScanReturn(walked, issues, renameOps, stats, options, setup);
+}
+function buildScanSetup(options) {
+  const start = Date.now();
+  const emitter = options.emitter ?? new InMemoryProgressEmitter();
+  const exts = options.extensions ?? { providers: [], extractors: [], analyzers: [] };
+  const hookDispatcher = makeHookDispatcher(exts.hooks ?? [], emitter);
+  const tokenize = options.tokenize !== false;
+  const encoder = tokenize ? new Tiktoken2(cl100k_base) : null;
+  const prior = options.priorSnapshot ?? null;
+  const priorIndex = indexPriorSnapshot(prior);
+  const providerFrontmatter = buildProviderFrontmatterValidator(exts.providers);
+  return {
+    start,
+    scannedAt: start,
+    emitter,
+    exts,
+    hookDispatcher,
+    encoder,
+    prior,
+    priorIndex,
+    priorExtractorRuns: options.priorExtractorRuns,
+    providerFrontmatter,
+    scope: options.scope ?? "project",
+    strict: options.strict === true,
+    enableCache: options.enableCache === true
+  };
+}
+async function dispatchExtractorCompleted(extractors, emitter, hookDispatcher) {
+  for (const extractor of extractors) {
+    const extractorId = qualifiedExtensionId(extractor.pluginId, extractor.id);
+    const evt = makeEvent("extractor.completed", { extractorId });
+    emitter.emit(evt);
+    await hookDispatcher.dispatch("extractor.completed", evt);
+  }
+}
+function mergeAnalyzerEmissions(walked, analyzerResult, analyzers) {
+  for (const c of analyzerResult.contributions) walked.contributions.push(c);
+  for (const analyzer of analyzers ?? []) {
+    if (analyzer.viewContributions === void 0) continue;
+    for (const node of walked.nodes) {
+      walked.freshlyRunTuples.add(`${analyzer.pluginId}\0${analyzer.id}\0${node.path}`);
+    }
+  }
+}
+function buildScanStats(walked, issues, start) {
+  return {
+    // `filesSkipped` is "files walked but not classified by any
+    // Provider". Today every walked file IS classified by its Provider
+    // (the `claude` Provider's `classify()` always returns a kind,
+    // falling back to `'markdown'`), so this is always 0. Wired now
+    // so the field shape is spec-conformant; meaningful once multiple
+    // Providers compete.
+    filesWalked: walked.filesWalked,
+    filesSkipped: 0,
+    nodesCount: walked.nodes.length,
+    linksCount: walked.internalLinks.length,
+    issuesCount: issues.length,
+    durationMs: Date.now() - start
+  };
+}
+function buildScanReturn(walked, issues, renameOps, stats, options, setup) {
+  return {
+    result: {
+      schemaVersion: 1,
+      scannedAt: setup.scannedAt,
+      scope: setup.scope,
+      roots: options.roots,
+      providers: setup.exts.providers.map((a) => a.id),
+      scannedBy: SCANNED_BY,
+      nodes: walked.nodes,
+      links: walked.internalLinks,
+      issues,
+      stats
+    },
+    renameOps,
+    extractorRuns: walked.extractorRuns,
+    enrichments: walked.enrichments,
+    contributions: walked.contributions,
+    freshlyRunTuples: walked.freshlyRunTuples
+  };
+}
+function validateRoots(roots) {
+  if (roots.length === 0) {
+    throw new Error(ORCHESTRATOR_TEXTS.runScanRootEmptyArray);
+  }
+  for (const root of roots) {
+    if (!existsSync9(root) || !statSync2(root).isDirectory()) {
+      throw new Error(tx(ORCHESTRATOR_TEXTS.runScanRootMissing, { root }));
+    }
+  }
+}
+
 // kernel/scan/watcher.ts
-import { resolve as resolve6, relative as relative4, sep as sep3 } from "path";
+import { resolve as resolve10, relative as relative4, sep as sep3 } from "path";
 import chokidar from "chokidar";
 function createChokidarWatcher(opts) {
-  const absRoots = opts.roots.map((r) => resolve6(opts.cwd, r));
+  const absRoots = opts.roots.map((r) => resolve10(opts.cwd, r));
   const ignoreFilterOpt = opts.ignoreFilter;
   const getFilter = ignoreFilterOpt === void 0 ? void 0 : typeof ignoreFilterOpt === "function" ? ignoreFilterOpt : () => ignoreFilterOpt;
   const ignored = getFilter ? (path) => {