@skill-map/cli 0.21.0 → 0.22.0

package/dist/index.js

@@ -92,18 +92,15 @@ var Registry = class {
   }
 };
 
-// kernel/orchestrator.ts
-import { createHash } from "crypto";
-import { existsSync as existsSync8, statSync as statSync2 } from "fs";
-import { isAbsolute as isAbsolute3, 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.21.0",
+  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.21.0",
+    "@skill-map/spec": "0.22.0",
     ajv: "8.18.0",
     "ajv-formats": "3.0.1",
     chokidar: "5.0.0",
@@ -206,12 +204,32 @@ var package_default = {
   }
 };
 
-// kernel/sidecar/parse.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, resolve } from "path";
+// kernel/adapters/in-memory-progress.ts
+var InMemoryProgressEmitter = class {
+  #listeners = /* @__PURE__ */ new Set();
+  emit(event) {
+    for (const listener of this.#listeners) listener(event);
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+};
+
+// 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/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";
-import yaml from "js-yaml";
 
 // kernel/util/ajv-interop.ts
 import addFormatsModule from "ajv-formats";
@@ -220,171 +238,128 @@ 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;
+// 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 = {
+  kvValidationFailed: "plugin '{{pluginId}}' ctx.store.set('{{key}}', value): value violates declared schema ({{schemaPath}}) \u2014 {{errors}}",
+  dedicatedValidationFailed: "plugin '{{pluginId}}' ctx.store.write('{{table}}', row): row violates declared schema ({{schemaPath}}) \u2014 {{errors}}"
+};
+
+// kernel/adapters/plugin-store.ts
+var KV_SCHEMA_KEY = "__kv__";
+function makeKvStoreWrapper(opts) {
+  const { pluginId, schema, persist } = opts;
   return {
-    parsed: {
-      filePath: sidecarPath,
-      identityBodyHash: String(identityBlock["bodyHash"]),
-      identityFrontmatterHash: String(identityBlock["frontmatterHash"]),
-      identityPath: String(identityBlock["path"]),
-      annotations,
-      raw: root
-    },
-    present: true,
-    issues: []
+    async set(key, value) {
+      if (schema) {
+        if (!schema.validate(value)) {
+          throw new Error(
+            tx(PLUGIN_STORE_TEXTS.kvValidationFailed, {
+              pluginId,
+              schemaPath: schema.schemaPath,
+              key,
+              errors: formatAjvErrors(schema.validate.errors ?? null)
+            })
+          );
+        }
+      }
+      await persist(key, value);
+    }
   };
 }
-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 makeDedicatedStoreWrapper(opts) {
+  const { pluginId, schemas, persist } = opts;
+  return {
+    async write(table, row) {
+      const schema = schemas?.[table];
+      if (schema) {
+        if (!schema.validate(row)) {
+          throw new Error(
+            tx(PLUGIN_STORE_TEXTS.dedicatedValidationFailed, {
+              pluginId,
+              table,
+              schemaPath: schema.schemaPath,
+              errors: formatAjvErrors(schema.validate.errors ?? null)
+            })
+          );
+        }
+      }
+      await persist(table, row);
+    }
+  };
 }
-function walk(root, current, shouldSkip, out) {
-  let entries;
-  try {
-    entries = readdirSync(current, { withFileTypes: true, encoding: "utf8" });
-  } catch {
-    return;
+function makePluginStore(opts) {
+  const manifest = opts.plugin.manifest;
+  if (!manifest?.storage) return void 0;
+  const storageSchemas = opts.plugin.storageSchemas;
+  if (manifest.storage.mode === "kv") {
+    if (!opts.persistKv) return void 0;
+    const schema = storageSchemas?.[KV_SCHEMA_KEY];
+    return makeKvStoreWrapper({
+      pluginId: manifest.id,
+      schema,
+      persist: opts.persistKv
+    });
   }
-  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 });
+  if (manifest.storage.mode === "dedicated") {
+    if (!opts.persistDedicated) return void 0;
+    return makeDedicatedStoreWrapper({
+      pluginId: manifest.id,
+      schemas: storageSchemas,
+      persist: opts.persistDedicated
+    });
   }
+  return void 0;
 }
-function safeIsFile(path) {
-  try {
-    return statSync(path).isFile();
-  } catch {
-    return false;
-  }
+function formatAjvErrors(errors) {
+  if (!errors || errors.length === 0) return "(no AJV details)";
+  return errors.map((e) => `${e.instancePath || "(root)"} ${e.message ?? e.keyword}`).join("; ");
 }
 
-// kernel/sidecar/store.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, renameSync as renameSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname4, resolve as resolve5 } from "path";
-import { createRequire as createRequire3 } from "module";
-import { Ajv2020 as Ajv20203 } from "ajv/dist/2020.js";
-import yaml2 from "js-yaml";
-
-// core/config/helper.ts
-import { isAbsolute, resolve as resolve4 } from "path";
-
-// kernel/config/loader.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+// kernel/adapters/plugin-loader/index.ts
+function installedSpecVersion() {
+  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(readFileSync2(pkgPath, "utf8"));
+  return pkg.version;
+}
 
 // kernel/adapters/schema-validators.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname, resolve as resolve4 } from "path";
 import { createRequire as createRequire2 } from "module";
-import { Ajv2020 as Ajv20202 } from "ajv/dist/2020.js";
+import { Ajv2020 as Ajv20203 } from "ajv/dist/2020.js";
 var SCHEMA_FILES = {
   node: "schemas/node.schema.json",
   link: "schemas/link.schema.json",
@@ -419,23 +394,23 @@ function loadSchemaValidators() {
   return cachedValidators;
 }
 function buildSchemaValidators() {
-  const specRoot = resolveSpecRoot2();
-  const ajv = new Ajv20202({
+  const specRoot = resolveSpecRoot();
+  const ajv = new Ajv20203({
     strict: false,
     allErrors: true,
     allowUnionTypes: true
   });
   applyAjvFormats(ajv);
   for (const rel of SUPPORTING_SCHEMAS) {
-    const file = resolve2(specRoot, rel);
+    const file = resolve4(specRoot, rel);
     if (!existsSyncSafe(file)) continue;
-    const schema = JSON.parse(readFileSync2(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 = resolve2(specRoot, rel);
-    const schema = JSON.parse(readFileSync2(file, "utf8"));
+    const file = resolve4(specRoot, rel);
+    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));
   }
@@ -515,15 +490,15 @@ function buildSchemaValidators() {
   };
 }
 function buildProviderFrontmatterValidator(providers) {
-  const specRoot = resolveSpecRoot2();
-  const ajv = new Ajv20202({
+  const specRoot = resolveSpecRoot();
+  const ajv = new Ajv20203({
     strict: false,
     allErrors: true,
     allowUnionTypes: true
   });
   applyAjvFormats(ajv);
-  const baseFile = resolve2(specRoot, "schemas/frontmatter/base.schema.json");
-  const baseSchema = JSON.parse(readFileSync2(baseFile, "utf8"));
+  const baseFile = resolve4(specRoot, "schemas/frontmatter/base.schema.json");
+  const baseSchema = JSON.parse(readFileSync3(baseFile, "utf8"));
   ajv.addSchema(baseSchema);
   registerProviderAuxiliarySchemas(ajv, providers);
   const compiled = /* @__PURE__ */ new Map();
@@ -560,11 +535,11 @@ function registerProviderAuxiliarySchemas(ajv, providers) {
     }
   }
 }
-function resolveSpecRoot2() {
+function resolveSpecRoot() {
   const require2 = createRequire2(import.meta.url);
   try {
     const indexPath = require2.resolve("@skill-map/spec/index.json");
-    return dirname2(indexPath);
+    return dirname(indexPath);
   } catch {
     throw new Error(
       "@skill-map/spec not resolvable \u2014 ensure the workspace is linked or the package is installed."
@@ -573,7 +548,7 @@ function resolveSpecRoot2() {
 }
 function existsSyncSafe(path) {
   try {
-    readFileSync2(path, "utf8");
+    readFileSync3(path, "utf8");
     return true;
   } catch {
     return false;
@@ -585,45 +560,6 @@ function formatErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-// kernel/util/skill-map-paths.ts
-import { join as join3 } from "path";
-
-// core/paths/db-path.ts
-import { join as join2, resolve as resolve3 } 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 existsSync4,
-  mkdirSync,
-  readFileSync as readFileSync4,
-  renameSync,
-  unlinkSync,
-  writeFileSync
-} from "fs";
-import { dirname as dirname3 } from "path";
-
-// kernel/adapters/in-memory-progress.ts
-var InMemoryProgressEmitter = class {
-  #listeners = /* @__PURE__ */ new Set();
-  emit(event) {
-    for (const listener of this.#listeners) listener(event);
-  }
-  subscribe(listener) {
-    this.#listeners.add(listener);
-    return () => {
-      this.#listeners.delete(listener);
-    };
-  }
-};
-
 // kernel/adapters/silent-logger.ts
 var SilentLogger = class {
   trace() {
@@ -657,115 +593,83 @@ function getActiveLogger() {
   return active;
 }
 
-// kernel/adapters/plugin-loader.ts
-import { createRequire as createRequire4 } from "module";
-import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync2 } from "fs";
-import { isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve6 } from "path";
-import { pathToFileURL } from "url";
-import { Ajv2020 as Ajv20204 } from "ajv/dist/2020.js";
-import semver from "semver";
-
-// kernel/i18n/plugin-store.texts.ts
-var PLUGIN_STORE_TEXTS = {
-  kvValidationFailed: "plugin '{{pluginId}}' ctx.store.set('{{key}}', value): value violates declared schema ({{schemaPath}}) \u2014 {{errors}}",
-  dedicatedValidationFailed: "plugin '{{pluginId}}' ctx.store.write('{{table}}', row): row violates declared schema ({{schemaPath}}) \u2014 {{errors}}"
-};
-
-// kernel/adapters/plugin-store.ts
-var KV_SCHEMA_KEY = "__kv__";
-function makeKvStoreWrapper(opts) {
-  const { pluginId, schema, persist } = opts;
-  return {
-    async set(key, value) {
-      if (schema) {
-        if (!schema.validate(value)) {
-          throw new Error(
-            tx(PLUGIN_STORE_TEXTS.kvValidationFailed, {
-              pluginId,
-              schemaPath: schema.schemaPath,
-              key,
-              errors: formatAjvErrors(schema.validate.errors ?? null)
-            })
-          );
-        }
-      }
-      await persist(key, value);
+// kernel/extensions/hook-dispatcher.ts
+function makeHookDispatcher(hooks, emitter) {
+  if (hooks.length === 0) {
+    return { dispatch: async () => {
+    } };
+  }
+  const byTrigger = /* @__PURE__ */ new Map();
+  for (const hook of hooks) {
+    if (hook.mode === "probabilistic") {
+      const qualifiedId = qualifiedExtensionId(hook.pluginId, hook.id);
+      log.warn(
+        `Probabilistic hook ${qualifiedId} deferred to job subsystem (future job subsystem). The hook is registered but will not dispatch in-scan.`,
+        { hookId: qualifiedId, mode: "probabilistic" }
+      );
+      continue;
     }
-  };
-}
-function makeDedicatedStoreWrapper(opts) {
-  const { pluginId, schemas, persist } = opts;
+    for (const trig of hook.triggers) {
+      const bucket = byTrigger.get(trig);
+      if (bucket) bucket.push(hook);
+      else byTrigger.set(trig, [hook]);
+    }
+  }
   return {
-    async write(table, row) {
-      const schema = schemas?.[table];
-      if (schema) {
-        if (!schema.validate(row)) {
-          throw new Error(
-            tx(PLUGIN_STORE_TEXTS.dedicatedValidationFailed, {
-              pluginId,
-              table,
-              schemaPath: schema.schemaPath,
-              errors: formatAjvErrors(schema.validate.errors ?? null)
+    async dispatch(trigger, event) {
+      const subs = byTrigger.get(trigger);
+      if (!subs || subs.length === 0) return;
+      for (const hook of subs) {
+        if (!matchesFilter(hook, event)) continue;
+        const ctx = buildHookContext(hook, trigger, event);
+        try {
+          await hook.on(ctx);
+        } catch (err) {
+          const qualifiedId = qualifiedExtensionId(hook.pluginId, hook.id);
+          const message = formatErrorMessage(err);
+          emitter.emit(
+            makeEvent("extension.error", {
+              kind: "hook-error",
+              extensionId: qualifiedId,
+              trigger,
+              message
             })
           );
         }
       }
-      await persist(table, row);
     }
   };
 }
-function makePluginStore(opts) {
-  const manifest = opts.plugin.manifest;
-  if (!manifest?.storage) return void 0;
-  const storageSchemas = opts.plugin.storageSchemas;
-  if (manifest.storage.mode === "kv") {
-    if (!opts.persistKv) return void 0;
-    const schema = storageSchemas?.[KV_SCHEMA_KEY];
-    return makeKvStoreWrapper({
-      pluginId: manifest.id,
-      schema,
-      persist: opts.persistKv
-    });
-  }
-  if (manifest.storage.mode === "dedicated") {
-    if (!opts.persistDedicated) return void 0;
-    return makeDedicatedStoreWrapper({
-      pluginId: manifest.id,
-      schemas: storageSchemas,
-      persist: opts.persistDedicated
-    });
-  }
-  return void 0;
+function makeEvent(type, data) {
+  return { type, timestamp: (/* @__PURE__ */ new Date()).toISOString(), data };
 }
-function formatAjvErrors(errors) {
-  if (!errors || errors.length === 0) return "(no AJV details)";
-  return errors.map((e) => `${e.instancePath || "(root)"} ${e.message ?? e.keyword}`).join("; ");
+function matchesFilter(hook, event) {
+  if (!hook.filter) return true;
+  const data = event.data ?? {};
+  for (const [key, expected] of Object.entries(hook.filter)) {
+    if (data[key] !== expected) return false;
+  }
+  return true;
 }
-
-// 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(", ");
-function installedSpecVersion() {
-  const require2 = createRequire4(import.meta.url);
-  const indexPath = require2.resolve("@skill-map/spec/index.json");
-  const pkgPath = resolve6(indexPath, "..", "package.json");
-  const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
-  return pkg.version;
+function buildHookContext(_hook, trigger, event) {
+  const data = event.data ?? {};
+  const ctx = {
+    event: {
+      type: trigger,
+      timestamp: event.timestamp,
+      ...event.runId !== void 0 ? { runId: event.runId } : {},
+      ...event.jobId !== void 0 ? { jobId: event.jobId } : {},
+      data: event.data
+    }
+  };
+  if (typeof data["extractorId"] === "string") ctx.extractorId = data["extractorId"];
+  if (typeof data["analyzerId"] === "string") ctx.analyzerId = data["analyzerId"];
+  if (typeof data["actionId"] === "string") ctx.actionId = data["actionId"];
+  if (data["node"] && typeof data["node"] === "object") {
+    ctx.node = data["node"];
+  }
+  if (data["jobResult"] !== void 0) ctx.jobResult = data["jobResult"];
+  return ctx;
 }
 
 // kernel/i18n/orchestrator.texts.ts
@@ -782,1081 +686,1004 @@ var ORCHESTRATOR_TEXTS = {
   runScanRootMissing: "runScan: root path '{{root}}' does not exist or is not a directory"
 };
 
-// kernel/scan/walk-content.ts
-import { readFile, readdir, stat } from "fs/promises";
-import { join as join5, relative as relative3, sep as sep2 } from "path";
-
-// kernel/scan/ignore.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname5, resolve as resolve7 } 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);
-  }
-  if (opts.ignoreFileText && opts.ignoreFileText.length > 0) {
-    ig.add(opts.ignoreFileText);
-  }
-  return {
-    ignores(relativePath) {
-      if (relativePath === "" || relativePath === "." || relativePath === "./") {
-        return false;
+// kernel/orchestrator/extractors.ts
+async function runExtractorsForNode(opts) {
+  const internalLinks = [];
+  const externalLinks = [];
+  const enrichmentBuffer = /* @__PURE__ */ new Map();
+  const contributions = [];
+  const validators = loadSchemaValidators();
+  for (const extractor of opts.extractors) {
+    const qualifiedId = qualifiedExtensionId(extractor.pluginId, extractor.id);
+    const emitLink = (link) => {
+      const validated = validateLink(extractor, link, opts.emitter);
+      if (!validated) return;
+      if (isExternalUrlLink(validated)) externalLinks.push(validated);
+      else internalLinks.push(validated);
+    };
+    const enrichNode = (partial) => {
+      const key = `${opts.node.path}\0${qualifiedId}`;
+      const existing = enrichmentBuffer.get(key);
+      if (existing) {
+        existing.value = { ...existing.value, ...partial };
+        existing.enrichedAt = Date.now();
+      } else {
+        enrichmentBuffer.set(key, {
+          nodePath: opts.node.path,
+          extractorId: qualifiedId,
+          bodyHashAtEnrichment: opts.bodyHash,
+          value: { ...partial },
+          enrichedAt: Date.now(),
+          // Extractors are deterministic-only; `is_probabilistic` is
+          // reserved on the row for future Action-issued enrichments.
+          isProbabilistic: 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 = dirname5(fileURLToPath(import.meta.url));
-  const candidates = [
-    resolve7(here, "../../config/defaults/skillmapignore"),
-    // src/kernel/scan/ → src/config/defaults/
-    resolve7(here, "../config/defaults/skillmapignore"),
-    // dist/cli.js → dist/config/defaults/ (siblings)
-    resolve7(here, "config/defaults/skillmapignore")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync7(candidate)) {
-      try {
-        return readFileSync7(candidate, "utf8");
-      } catch {
+    };
+    const declaredContributions = readDeclaredContributions(extractor);
+    const emitContribution = (contributionId, payload) => {
+      const declared = declaredContributions.get(contributionId);
+      if (!declared) {
+        emitExtensionError(opts.emitter, qualifiedId, opts.node.path, {
+          phase: "emitContribution",
+          contributionId,
+          reason: "unknown-contribution-id",
+          message: tx(ORCHESTRATOR_TEXTS.extensionErrorContributionUnknownId, {
+            extractorId: qualifiedId,
+            contributionId,
+            nodePath: opts.node.path
+          })
+        });
+        return;
       }
-    }
+      const result = validators.validateContributionPayload(declared.slot, payload);
+      if (!result.ok) {
+        emitExtensionError(opts.emitter, qualifiedId, opts.node.path, {
+          phase: "emitContribution",
+          contributionId,
+          slot: declared.slot,
+          reason: result.errors,
+          message: tx(ORCHESTRATOR_TEXTS.extensionErrorContributionPayloadInvalid, {
+            extractorId: qualifiedId,
+            contributionId,
+            nodePath: opts.node.path,
+            slot: declared.slot,
+            errors: result.errors
+          })
+        });
+        return;
+      }
+      contributions.push({
+        pluginId: extractor.pluginId,
+        extensionId: extractor.id,
+        nodePath: opts.node.path,
+        contributionId,
+        slot: declared.slot,
+        payload,
+        emittedAt: Date.now()
+      });
+    };
+    const store = opts.pluginStores?.get(extractor.pluginId);
+    const ctx = buildExtractorContext(
+      extractor,
+      opts.node,
+      opts.body,
+      opts.frontmatter,
+      emitLink,
+      enrichNode,
+      emitContribution,
+      store
+    );
+    await extractor.extract(ctx);
   }
-  return "";
+  return {
+    internalLinks,
+    externalLinks,
+    enrichments: Array.from(enrichmentBuffer.values()),
+    contributions
+  };
 }
-
-// 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 };
+function readDeclaredContributions(extension) {
+  const out = /* @__PURE__ */ new Map();
+  const raw = extension.viewContributions;
+  if (typeof raw !== "object" || raw === null) return out;
+  for (const [id, value] of Object.entries(raw)) {
+    if (typeof value !== "object" || value === null) continue;
+    const slot = value.slot;
+    if (typeof slot !== "string") continue;
+    out.set(id, { slot });
   }
-};
-
-// built-in-plugins/parsers/plain/index.ts
-var plainParser = {
-  id: "plain",
-  parse(raw, _path) {
-    return { frontmatter: {}, frontmatterRaw: "", body: raw };
+  return out;
+}
+function emitExtensionError(emitter, qualifiedId, nodePath, data) {
+  emitter.emit(
+    makeEvent("extension.error", {
+      kind: "contribution-rejected",
+      extensionId: qualifiedId,
+      nodePath,
+      ...data
+    })
+  );
+}
+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 } : {}
+  };
+}
+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(", ")
+        })
+      })
+    );
+    return null;
   }
-};
-
-// 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);
+  const confidence = link.confidence ?? extractor.defaultConfidence;
+  return { ...link, confidence };
 }
-
-// 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";
+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);
   }
-};
-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
-      };
-    }
+  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;
   }
 }
-async function* walkRoot(root, current, filter, extensions) {
-  let entries;
-  try {
-    entries = await readdir(current, { withFileTypes: true, encoding: "utf8" });
-  } catch {
-    return;
+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);
   }
-  for (const entry of entries) {
-    const name = entry.name;
-    const full = join5(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 {
-      }
-    }
+  for (const link of externalLinks) {
+    const source = byPath2.get(link.source);
+    if (source && !cachedPaths.has(source.path)) source.externalRefsCount += 1;
   }
 }
-function hasMatchingExtension(name, extensions) {
-  for (const ext of extensions) {
-    if (name.endsWith(ext)) return true;
-  }
-  return false;
+var EXTERNAL_URL_SCHEME_RE = /^[a-z][a-z0-9+\-.]+:/i;
+function isExternalUrlLink(link) {
+  return EXTERNAL_URL_SCHEME_RE.test(link.target);
 }
 
-// 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
+// kernel/orchestrator/analyzers.ts
+async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, orphanJobFiles, referenceablePaths, cwd, emitter, hookDispatcher) {
+  const issues = [];
+  const contributions = [];
+  const validators = loadSchemaValidators();
+  const analyzerOrphans = orphanSidecars.map((o) => ({
+    relativePath: o.relativePath,
+    expectedMdPath: o.expectedMdPath
+  }));
+  for (const analyzer of analyzers) {
+    const qualifiedId = qualifiedExtensionId(analyzer.pluginId, analyzer.id);
+    const declaredContributions = readDeclaredContributions(analyzer);
+    const emitContribution = (nodePath, contributionId, payload) => {
+      const declared = declaredContributions.get(contributionId);
+      if (!declared) {
+        emitExtensionError(emitter, qualifiedId, nodePath, {
+          phase: "emitContribution",
+          contributionId,
+          reason: "unknown-contribution-id",
+          message: tx(ORCHESTRATOR_TEXTS.extensionErrorContributionUnknownId, {
+            extractorId: qualifiedId,
+            contributionId,
+            nodePath
+          })
+        });
+        return;
+      }
+      const result = validators.validateContributionPayload(declared.slot, payload);
+      if (!result.ok) {
+        emitExtensionError(emitter, qualifiedId, nodePath, {
+          phase: "emitContribution",
+          contributionId,
+          slot: declared.slot,
+          reason: result.errors,
+          message: tx(ORCHESTRATOR_TEXTS.extensionErrorContributionPayloadInvalid, {
+            extractorId: qualifiedId,
+            contributionId,
+            nodePath,
+            slot: declared.slot,
+            errors: result.errors
+          })
+        });
+        return;
+      }
+      contributions.push({
+        pluginId: analyzer.pluginId,
+        extensionId: analyzer.id,
+        nodePath,
+        contributionId,
+        slot: declared.slot,
+        payload,
+        emittedAt: Date.now()
+      });
     };
-    if (options?.ignoreFilter) walkOptions.ignoreFilter = options.ignoreFilter;
-    return walkContent(roots, walkOptions);
-  };
+    const emitted = await analyzer.evaluate({
+      nodes,
+      links: internalLinks,
+      orphanSidecars: analyzerOrphans,
+      sidecarRoots,
+      annotationContributions,
+      viewContributions,
+      orphanJobFiles,
+      ...referenceablePaths ? { referenceablePaths } : {},
+      ...cwd ? { cwd } : {},
+      emitContribution
+    });
+    for (const issue of emitted) {
+      const validated = validateIssue(analyzer, issue, emitter);
+      if (validated) issues.push(validated);
+    }
+    const evt = makeEvent("analyzer.completed", { analyzerId: qualifiedId });
+    emitter.emit(evt);
+    await hookDispatcher.dispatch("analyzer.completed", evt);
+  }
+  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/extensions/hook-dispatcher.ts
-function makeHookDispatcher(hooks, emitter) {
-  if (hooks.length === 0) {
-    return { dispatch: async () => {
-    } };
+// 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 };
   }
-  const byTrigger = /* @__PURE__ */ new Map();
-  for (const hook of hooks) {
-    if (hook.mode === "probabilistic") {
-      const qualifiedId = qualifiedExtensionId(hook.pluginId, hook.id);
-      log.warn(
-        `Probabilistic hook ${qualifiedId} deferred to job subsystem (future job subsystem). The hook is registered but will not dispatch in-scan.`,
-        { hookId: qualifiedId, mode: "probabilistic" }
-      );
-      continue;
-    }
-    for (const trig of hook.triggers) {
-      const bucket = byTrigger.get(trig);
-      if (bucket) bucket.push(hook);
-      else byTrigger.set(trig, [hook]);
-    }
+  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);
   }
-  return {
-    async dispatch(trigger, event) {
-      const subs = byTrigger.get(trigger);
-      if (!subs || subs.length === 0) return;
-      for (const hook of subs) {
-        if (!matchesFilter(hook, event)) continue;
-        const ctx = buildHookContext(hook, trigger, event);
-        try {
-          await hook.on(ctx);
-        } catch (err) {
-          const qualifiedId = qualifiedExtensionId(hook.pluginId, hook.id);
-          const message = formatErrorMessage(err);
-          emitter.emit(
-            makeEvent("extension.error", {
-              kind: "hook-error",
-              extensionId: qualifiedId,
-              trigger,
-              message
-            })
-          );
-        }
-      }
-    }
-  };
 }
-function makeEvent(type, data) {
-  return { type, timestamp: (/* @__PURE__ */ new Date()).toISOString(), data };
+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 matchesFilter(hook, event) {
-  if (!hook.filter) return true;
-  const data = event.data ?? {};
-  for (const [key, expected] of Object.entries(hook.filter)) {
-    if (data[key] !== expected) return false;
+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]);
   }
-  return true;
 }
-function buildHookContext(_hook, trigger, event) {
-  const data = event.data ?? {};
-  const ctx = {
-    event: {
-      type: trigger,
-      timestamp: event.timestamp,
-      ...event.runId !== void 0 ? { runId: event.runId } : {},
-      ...event.jobId !== void 0 ? { jobId: event.jobId } : {},
-      data: event.data
-    }
-  };
-  if (typeof data["extractorId"] === "string") ctx.extractorId = data["extractorId"];
-  if (typeof data["analyzerId"] === "string") ctx.analyzerId = data["analyzerId"];
-  if (typeof data["actionId"] === "string") ctx.actionId = data["actionId"];
-  if (data["node"] && typeof data["node"] === "object") {
-    ctx.node = data["node"];
+function originatingNodeOf(link, priorNodePaths) {
+  if (link.kind === "supersedes" && !priorNodePaths.has(link.source)) {
+    return link.target;
   }
-  if (data["jobResult"] !== void 0) ctx.jobResult = data["jobResult"];
-  return ctx;
+  return link.source;
 }
-
-// kernel/orchestrator.ts
-var SCANNED_BY = {
-  name: "skill-map",
-  version: package_default.version,
-  specVersion: resolveSpecVersionSafe()
-};
-function resolveSpecVersionSafe() {
-  try {
-    return installedSpecVersion();
-  } catch {
-    return "unknown";
+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 };
 }
-async function runScanWithRenames(_kernel, options) {
-  return runScanInternal(_kernel, options);
+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 };
 }
-async function runScan(_kernel, options) {
-  const { result } = await runScanInternal(_kernel, options);
-  return result;
+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 };
 }
-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);
+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
+    });
   }
-  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
+  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
   );
-  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}\0${analyzer.id}\0${node.path}`);
+  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) {
+    if (opts.claimedDeleted.has(fromPath)) continue;
+    const fromNode = opts.priorByPath.get(fromPath);
+    for (const toPath of opts.newPaths) {
+      if (opts.claimedNew.has(toPath)) continue;
+      const toNode = opts.currentByPath.get(toPath);
+      if (toNode.bodyHash === fromNode.bodyHash) {
+        ops.push({ from: fromPath, to: toPath, confidence: "high" });
+        opts.claimedDeleted.add(fromPath);
+        opts.claimedNew.add(toPath);
+        break;
+      }
     }
   }
-  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
-  };
+  return ops;
 }
-function validateRoots(roots) {
-  if (roots.length === 0) {
-    throw new Error(ORCHESTRATOR_TEXTS.runScanRootEmptyArray);
+function buildFrontmatterRenameCandidates(opts) {
+  const candidatesByNew = /* @__PURE__ */ new Map();
+  for (const toPath of opts.newPaths) {
+    if (opts.claimedNew.has(toPath)) continue;
+    const toNode = opts.currentByPath.get(toPath);
+    const matches = [];
+    for (const fromPath of opts.deletedPaths) {
+      if (opts.claimedDeleted.has(fromPath)) continue;
+      const fromNode = opts.priorByPath.get(fromPath);
+      if (toNode.frontmatterHash === fromNode.frontmatterHash) {
+        matches.push(fromPath);
+      }
+    }
+    if (matches.length > 0) candidatesByNew.set(toPath, matches);
   }
-  for (const root of roots) {
-    if (!existsSync8(root) || !statSync2(root).isDirectory()) {
-      throw new Error(tx(ORCHESTRATOR_TEXTS.runScanRootMissing, { root }));
+  return candidatesByNew;
+}
+function claimSingletonRenames(opts) {
+  const ops = [];
+  for (const toPath of opts.newPaths) {
+    if (opts.claimedNew.has(toPath)) continue;
+    const candidates = opts.candidatesByNew.get(toPath);
+    if (!candidates) continue;
+    const remaining = candidates.filter((p) => !opts.claimedDeleted.has(p));
+    if (remaining.length === 1) {
+      const fromPath = remaining[0];
+      ops.push({ from: fromPath, to: toPath, confidence: "medium" });
+      opts.issues.push({
+        analyzerId: "auto-rename-medium",
+        severity: "warn",
+        nodeIds: [toPath],
+        message: `Auto-rename (medium confidence): ${fromPath} \u2192 ${toPath}`,
+        data: { from: fromPath, to: toPath, confidence: "medium" }
+      });
+      opts.claimedDeleted.add(fromPath);
+      opts.claimedNew.add(toPath);
     }
   }
+  return ops;
 }
-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 };
+function flagAmbiguousRenames(opts) {
+  for (const toPath of opts.newPaths) {
+    if (opts.claimedNew.has(toPath)) continue;
+    const candidates = opts.candidatesByNew.get(toPath);
+    if (!candidates) continue;
+    const remaining = candidates.filter((p) => !opts.claimedDeleted.has(p));
+    if (remaining.length > 1) {
+      opts.issues.push({
+        analyzerId: "auto-rename-ambiguous",
+        severity: "warn",
+        nodeIds: [toPath],
+        message: `Auto-rename ambiguous: ${toPath} matches ${remaining.length} prior frontmatters \u2014 pick one with \`sm orphans undo-rename ${toPath} --from <old.path>\`.`,
+        data: { to: toPath, candidates: remaining }
+      });
+    }
   }
-  for (const node of prior.nodes) {
-    priorNodesByPath.set(node.path, node);
-    priorNodePaths.add(node.path);
+}
+function flagOrphans(opts) {
+  for (const fromPath of opts.deletedPaths) {
+    if (opts.claimedDeleted.has(fromPath)) continue;
+    opts.issues.push({
+      analyzerId: "orphan",
+      severity: "info",
+      nodeIds: [fromPath],
+      message: `Orphan history: ${fromPath} was deleted; no rename match found.`,
+      data: { path: fromPath }
+    });
   }
-  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]);
+}
+function detectRenamesAndOrphans(prior, current, issues) {
+  const priorByPath = /* @__PURE__ */ new Map();
+  for (const n of prior.nodes) priorByPath.set(n.path, n);
+  const currentByPath = /* @__PURE__ */ new Map();
+  for (const n of current) currentByPath.set(n.path, n);
+  const deletedPaths = [...priorByPath.keys()].filter((p) => !currentByPath.has(p)).sort();
+  const newPaths = [...currentByPath.keys()].filter((p) => !priorByPath.has(p)).sort();
+  const claimedDeleted = /* @__PURE__ */ new Set();
+  const claimedNew = /* @__PURE__ */ new Set();
+  const ops = [];
+  ops.push(...findHighConfidenceRenames({
+    deletedPaths,
+    newPaths,
+    priorByPath,
+    currentByPath,
+    claimedDeleted,
+    claimedNew
+  }));
+  const candidatesByNew = buildFrontmatterRenameCandidates({
+    deletedPaths,
+    newPaths,
+    priorByPath,
+    currentByPath,
+    claimedDeleted,
+    claimedNew
+  });
+  ops.push(...claimSingletonRenames({
+    newPaths,
+    candidatesByNew,
+    claimedDeleted,
+    claimedNew,
+    issues
+  }));
+  flagAmbiguousRenames({ newPaths, candidatesByNew, claimedDeleted, claimedNew, issues });
+  flagOrphans({ deletedPaths, claimedDeleted, issues });
+  return ops;
+}
+
+// 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());
   }
-  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]);
+  if (opts.configIgnore && opts.configIgnore.length > 0) {
+    ig.add(opts.configIgnore);
   }
-  return { priorNodesByPath, priorNodePaths, priorLinksByOriginating, priorFrontmatterIssuesByNode };
-}
-async function runExtractorsForNode(opts) {
-  const internalLinks = [];
-  const externalLinks = [];
-  const enrichmentBuffer = /* @__PURE__ */ new Map();
-  const contributions = [];
-  const validators = loadSchemaValidators();
-  for (const extractor of opts.extractors) {
-    const qualifiedId = qualifiedExtensionId(extractor.pluginId, extractor.id);
-    const emitLink = (link) => {
-      const validated = validateLink(extractor, link, opts.emitter);
-      if (!validated) return;
-      if (isExternalUrlLink(validated)) externalLinks.push(validated);
-      else internalLinks.push(validated);
-    };
-    const enrichNode = (partial) => {
-      const key = `${opts.node.path}\0${qualifiedId}`;
-      const existing = enrichmentBuffer.get(key);
-      if (existing) {
-        existing.value = { ...existing.value, ...partial };
-        existing.enrichedAt = Date.now();
-      } else {
-        enrichmentBuffer.set(key, {
-          nodePath: opts.node.path,
-          extractorId: qualifiedId,
-          bodyHashAtEnrichment: opts.bodyHash,
-          value: { ...partial },
-          enrichedAt: Date.now(),
-          // Extractors are deterministic-only; `is_probabilistic` is
-          // reserved on the row for future Action-issued enrichments.
-          isProbabilistic: false
-        });
+  if (opts.ignoreFileText && opts.ignoreFileText.length > 0) {
+    ig.add(opts.ignoreFileText);
+  }
+  return {
+    ignores(relativePath) {
+      if (relativePath === "" || relativePath === "." || relativePath === "./") {
+        return false;
       }
-    };
-    const declaredContributions = readDeclaredContributions(extractor);
-    const emitContribution = (contributionId, payload) => {
-      const declared = declaredContributions.get(contributionId);
-      if (!declared) {
-        emitExtensionError(opts.emitter, qualifiedId, opts.node.path, {
-          phase: "emitContribution",
-          contributionId,
-          reason: "unknown-contribution-id",
-          message: tx(ORCHESTRATOR_TEXTS.extensionErrorContributionUnknownId, {
-            extractorId: qualifiedId,
-            contributionId,
-            nodePath: opts.node.path
-          })
-        });
-        return;
+      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 = 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 {
       }
-      const result = validators.validateContributionPayload(declared.slot, payload);
-      if (!result.ok) {
-        emitExtensionError(opts.emitter, qualifiedId, opts.node.path, {
-          phase: "emitContribution",
-          contributionId,
-          slot: declared.slot,
-          reason: result.errors,
-          message: tx(ORCHESTRATOR_TEXTS.extensionErrorContributionPayloadInvalid, {
-            extractorId: qualifiedId,
-            contributionId,
-            nodePath: opts.node.path,
-            slot: declared.slot,
-            errors: result.errors
-          })
-        });
-        return;
+    }
+  }
+  return "";
+}
+
+// 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;
+        }
       }
-      contributions.push({
-        pluginId: extractor.pluginId,
-        extensionId: extractor.id,
-        nodePath: opts.node.path,
-        contributionId,
-        slot: declared.slot,
-        payload,
-        emittedAt: Date.now()
-      });
-    };
-    const store = opts.pluginStores?.get(extractor.pluginId);
-    const ctx = buildExtractorContext(
-      extractor,
-      opts.node,
-      opts.body,
-      opts.frontmatter,
-      emitLink,
-      enrichNode,
-      emitContribution,
-      store
-    );
-    await extractor.extract(ctx);
+    } 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 };
   }
-  return {
-    internalLinks,
-    externalLinks,
-    enrichments: Array.from(enrichmentBuffer.values()),
-    contributions
-  };
+};
+
+// 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);
 }
-function readDeclaredContributions(extension) {
-  const out = /* @__PURE__ */ new Map();
-  const raw = extension.viewContributions;
-  if (typeof raw !== "object" || raw === null) return out;
-  for (const [id, value] of Object.entries(raw)) {
-    if (typeof value !== "object" || value === null) continue;
-    const slot = value.slot;
-    if (typeof slot !== "string") continue;
-    out.set(id, { slot });
+
+// 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";
   }
-  return out;
-}
-function emitExtensionError(emitter, qualifiedId, nodePath, data) {
-  emitter.emit(
-    makeEvent("extension.error", {
-      kind: "contribution-rejected",
-      extensionId: 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 prior = priorRunsForNode.get(qualified);
-      const bodyMatch = prior !== void 0 && prior.bodyHash === opts.bodyHash;
-      const sidecarOk = prior !== void 0 && prior.sidecarAnnotationsHash === opts.sidecarAnnotationsHash;
-      if (opts.nodeHashCacheEligible && bodyMatch && sidecarOk) {
-        cachedQualifiedIds.add(qualified);
-      } else {
-        missingExtractors.push(ex);
+};
+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
+      };
     }
   }
-  return {
-    applicableExtractors,
-    applicableQualifiedIds,
-    cachedQualifiedIds,
-    missingExtractors,
-    fullCacheHit: opts.nodeHashCacheEligible && missingExtractors.length === 0
-  };
 }
-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);
+async function* walkRoot(root, current, filter, extensions) {
+  let entries;
+  try {
+    entries = await readdir(current, { withFileTypes: true, encoding: "utf8" });
+  } catch {
+    return;
   }
-  const frontmatterIssues = [];
-  const reusedFm = opts.priorFrontmatterIssuesByNode.get(opts.priorNode.path) ?? [];
-  for (const issue of reusedFm) {
-    frontmatterIssues.push({ ...issue, severity: opts.strict ? "error" : "warn" });
+  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 {
+      }
+    }
   }
-  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
-    });
+function hasMatchingExtension(name, extensions) {
+  for (const ext of extensions) {
+    if (name.endsWith(ext)) return true;
   }
-  return { ...base, extractorRuns };
+  return false;
 }
-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);
+
+// 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;
   }
-  return { node, frontmatterIssues };
+  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);
+  };
 }
-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]);
+
+// 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: [] };
   }
-  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 sidecarResolution = resolveSidecarOverlay(
-        raw.path,
-        raw.path,
-        roots,
-        bodyHash,
-        frontmatterHash
-      );
-      const sidecarAnnotationsHash = sha256(
-        canonicalSidecarAnnotations(sidecarResolution.overlay.annotations)
-      );
-      const cacheDecision = computeCacheDecision({
-        extractors,
-        kind,
-        nodePath: raw.path,
-        bodyHash,
-        sidecarAnnotationsHash,
-        nodeHashCacheEligible,
-        priorExtractorRuns
-      });
-      const {
-        applicableExtractors,
-        applicableQualifiedIds,
-        cachedQualifiedIds,
-        missingExtractors,
-        fullCacheHit
-      } = cacheDecision;
-      const attachSidecar = (node2) => {
-        node2.sidecar = sidecarResolution.overlay;
-        if (sidecarResolution.parsedRoot !== null) {
-          sidecarRoots.set(node2.path, sidecarResolution.parsedRoot);
-        }
-        return sidecarResolution.issues.map(
-          (i) => i.nodeIds.length > 0 ? i : { ...i, nodeIds: [node2.path] }
-        );
-      };
-      if (fullCacheHit && priorNode) {
-        const reused = reusePriorNode({
-          priorNode,
-          bodyHash,
-          sidecarAnnotationsHash,
-          strict,
-          cachedQualifiedIds,
-          applicableQualifiedIds,
-          shortIdToQualified,
-          priorLinksByOriginating,
-          priorFrontmatterIssuesByNode
-        });
-        const reusedSidecarIssues = attachSidecar(reused.node);
-        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 = attachSidecar(node);
-      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}\0${ex.id}\0${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,
-          sidecarAnnotationsHashAtRun: sidecarAnnotationsHash
-        });
-      }
-    }
+  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 orphanSidecars = discoverOrphanSidecars(roots);
+  const root = parsedYaml;
+  const identityBlock = root["identity"];
+  const annotationsRaw = root["annotations"];
+  const annotations = isPlainObject(annotationsRaw) ? Object.keys(annotationsRaw).length === 0 ? null : annotationsRaw : null;
   return {
-    nodes,
-    internalLinks,
-    externalLinks,
-    cachedPaths,
-    frontmatterIssues,
-    filesWalked,
-    enrichments: [...enrichmentBuffer.values()],
-    extractorRuns,
-    contributions: contributionsBuffer,
-    freshlyRunTuples,
-    orphanSidecars,
-    sidecarRoots
+    parsed: {
+      filePath: sidecarPath,
+      identityBodyHash: String(identityBlock["bodyHash"]),
+      identityFrontmatterHash: String(identityBlock["frontmatterHash"]),
+      identityPath: String(identityBlock["path"]),
+      annotations,
+      raw: root
+    },
+    present: true,
+    issues: []
   };
 }
-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);
+function sidecarPathFor(mdAbsolutePath) {
+  if (mdAbsolutePath.endsWith(".md")) {
+    return `${mdAbsolutePath.slice(0, -".md".length)}.sm`;
   }
-  if (hasMissing) return null;
-  if (cachedSources.length === 0) return null;
-  if (obsoleteSources.length === 0) return link;
-  return { ...link, sources: cachedSources };
+  return `${mdAbsolutePath}.sm`;
 }
-async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, orphanJobFiles, referenceablePaths, cwd, emitter, hookDispatcher) {
-  const issues = [];
-  const contributions = [];
-  const validators = loadSchemaValidators();
-  const analyzerOrphans = orphanSidecars.map((o) => ({
-    relativePath: o.relativePath,
-    expectedMdPath: o.expectedMdPath
-  }));
-  for (const analyzer of analyzers) {
-    const qualifiedId = qualifiedExtensionId(analyzer.pluginId, analyzer.id);
-    const declaredContributions = readDeclaredContributions(analyzer);
-    const emitContribution = (nodePath, contributionId, payload) => {
-      const declared = declaredContributions.get(contributionId);
-      if (!declared) {
-        emitExtensionError(emitter, qualifiedId, nodePath, {
-          phase: "emitContribution",
-          contributionId,
-          reason: "unknown-contribution-id",
-          message: tx(ORCHESTRATOR_TEXTS.extensionErrorContributionUnknownId, {
-            extractorId: qualifiedId,
-            contributionId,
-            nodePath
-          })
-        });
-        return;
-      }
-      const result = validators.validateContributionPayload(declared.slot, payload);
-      if (!result.ok) {
-        emitExtensionError(emitter, qualifiedId, nodePath, {
-          phase: "emitContribution",
-          contributionId,
-          slot: declared.slot,
-          reason: result.errors,
-          message: tx(ORCHESTRATOR_TEXTS.extensionErrorContributionPayloadInvalid, {
-            extractorId: qualifiedId,
-            contributionId,
-            nodePath,
-            slot: declared.slot,
-            errors: result.errors
-          })
-        });
-        return;
-      }
-      contributions.push({
-        pluginId: analyzer.pluginId,
-        extensionId: analyzer.id,
-        nodePath,
-        contributionId,
-        slot: declared.slot,
-        payload,
-        emittedAt: Date.now()
-      });
-    };
-    const emitted = await analyzer.evaluate({
-      nodes,
-      links: internalLinks,
-      orphanSidecars: analyzerOrphans,
-      sidecarRoots,
-      annotationContributions,
-      viewContributions,
-      orphanJobFiles,
-      ...referenceablePaths ? { referenceablePaths } : {},
-      ...cwd ? { cwd } : {},
-      emitContribution
-    });
-    for (const issue of emitted) {
-      const validated = validateIssue(analyzer, issue, emitter);
-      if (validated) issues.push(validated);
-    }
-    const evt = makeEvent("analyzer.completed", { analyzerId: qualifiedId });
-    emitter.emit(evt);
-    await hookDispatcher.dispatch("analyzer.completed", evt);
+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 { issues, contributions };
 }
-function originatingNodeOf(link, priorNodePaths) {
-  if (link.kind === "supersedes" && !priorNodePaths.has(link.source)) {
-    return link.target;
+
+// 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 link.source;
+  return out;
 }
-function findHighConfidenceRenames(opts) {
-  const ops = [];
-  for (const fromPath of opts.deletedPaths) {
-    if (opts.claimedDeleted.has(fromPath)) continue;
-    const fromNode = opts.priorByPath.get(fromPath);
-    for (const toPath of opts.newPaths) {
-      if (opts.claimedNew.has(toPath)) continue;
-      const toNode = opts.currentByPath.get(toPath);
-      if (toNode.bodyHash === fromNode.bodyHash) {
-        ops.push({ from: fromPath, to: toPath, confidence: "high" });
-        opts.claimedDeleted.add(fromPath);
-        opts.claimedNew.add(toPath);
-        break;
-      }
+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 });
   }
-  return ops;
 }
-function buildFrontmatterRenameCandidates(opts) {
-  const candidatesByNew = /* @__PURE__ */ new Map();
-  for (const toPath of opts.newPaths) {
-    if (opts.claimedNew.has(toPath)) continue;
-    const toNode = opts.currentByPath.get(toPath);
-    const matches = [];
-    for (const fromPath of opts.deletedPaths) {
-      if (opts.claimedDeleted.has(fromPath)) continue;
-      const fromNode = opts.priorByPath.get(fromPath);
-      if (toNode.frontmatterHash === fromNode.frontmatterHash) {
-        matches.push(fromPath);
-      }
-    }
-    if (matches.length > 0) candidatesByNew.set(toPath, matches);
+function safeIsFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
   }
-  return candidatesByNew;
 }
-function claimSingletonRenames(opts) {
-  const ops = [];
-  for (const toPath of opts.newPaths) {
-    if (opts.claimedNew.has(toPath)) continue;
-    const candidates = opts.candidatesByNew.get(toPath);
-    if (!candidates) continue;
-    const remaining = candidates.filter((p) => !opts.claimedDeleted.has(p));
-    if (remaining.length === 1) {
-      const fromPath = remaining[0];
-      ops.push({ from: fromPath, to: toPath, confidence: "medium" });
-      opts.issues.push({
-        analyzerId: "auto-rename-medium",
-        severity: "warn",
-        nodeIds: [toPath],
-        message: `Auto-rename (medium confidence): ${fromPath} \u2192 ${toPath}`,
-        data: { from: fromPath, to: toPath, confidence: "medium" }
-      });
-      opts.claimedDeleted.add(fromPath);
-      opts.claimedNew.add(toPath);
+
+// 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;
+  return {
+    analyzerId: "frontmatter-invalid",
+    severity: strict ? "error" : "warn",
+    nodeIds: [path],
+    message: tx(ORCHESTRATOR_TEXTS.frontmatterInvalid, { path, kind, errors: result.errors }),
+    data: { kind, errors: result.errors }
+  };
+}
+function detectMalformedFrontmatter(body, path, strict) {
+  const hint = classifyMalformedFrontmatter(body);
+  if (!hint) return null;
+  return {
+    analyzerId: "frontmatter-malformed",
+    severity: strict ? "error" : "warn",
+    nodeIds: [path],
+    message: malformedMessage(hint, path),
+    data: { hint }
+  };
+}
+function classifyMalformedFrontmatter(body) {
+  if (body.startsWith("\uFEFF")) {
+    if (/^---\r?\n[\s\S]*?[A-Za-z0-9_-]+\s*:/.test(body)) {
+      return "byte-order-mark";
     }
   }
-  return ops;
-}
-function flagAmbiguousRenames(opts) {
-  for (const toPath of opts.newPaths) {
-    if (opts.claimedNew.has(toPath)) continue;
-    const candidates = opts.candidatesByNew.get(toPath);
-    if (!candidates) continue;
-    const remaining = candidates.filter((p) => !opts.claimedDeleted.has(p));
-    if (remaining.length > 1) {
-      opts.issues.push({
-        analyzerId: "auto-rename-ambiguous",
-        severity: "warn",
-        nodeIds: [toPath],
-        message: `Auto-rename ambiguous: ${toPath} matches ${remaining.length} prior frontmatters \u2014 pick one with \`sm orphans undo-rename ${toPath} --from <old.path>\`.`,
-        data: { to: toPath, candidates: remaining }
-      });
+  if (/^[ \t]+---\r?\n[ \t]*[A-Za-z0-9_-]+\s*:/.test(body)) {
+    return "paste-with-indent";
+  }
+  if (/^---\r?\n[ \t]*[A-Za-z0-9_-]+\s*:/.test(body)) {
+    const hasCloseFence = /\r?\n---(?:\r?\n|$)/.test(body);
+    if (!hasCloseFence) {
+      return "missing-close";
     }
   }
+  return null;
 }
-function flagOrphans(opts) {
-  for (const fromPath of opts.deletedPaths) {
-    if (opts.claimedDeleted.has(fromPath)) continue;
-    opts.issues.push({
-      analyzerId: "orphan",
-      severity: "info",
-      nodeIds: [fromPath],
-      message: `Orphan history: ${fromPath} was deleted; no rename match found.`,
-      data: { path: fromPath }
-    });
+function malformedMessage(hint, path) {
+  switch (hint) {
+    case "paste-with-indent":
+      return tx(ORCHESTRATOR_TEXTS.frontmatterMalformedPasteWithIndent, { path });
+    case "byte-order-mark":
+      return tx(ORCHESTRATOR_TEXTS.frontmatterMalformedByteOrderMark, { path });
+    case "missing-close":
+      return tx(ORCHESTRATOR_TEXTS.frontmatterMalformedMissingClose, { path });
   }
 }
-function detectRenamesAndOrphans(prior, current, issues) {
-  const priorByPath = /* @__PURE__ */ new Map();
-  for (const n of prior.nodes) priorByPath.set(n.path, n);
-  const currentByPath = /* @__PURE__ */ new Map();
-  for (const n of current) currentByPath.set(n.path, n);
-  const deletedPaths = [...priorByPath.keys()].filter((p) => !currentByPath.has(p)).sort();
-  const newPaths = [...currentByPath.keys()].filter((p) => !priorByPath.has(p)).sort();
-  const claimedDeleted = /* @__PURE__ */ new Set();
-  const claimedNew = /* @__PURE__ */ new Set();
-  const ops = [];
-  ops.push(...findHighConfidenceRenames({
-    deletedPaths,
-    newPaths,
-    priorByPath,
-    currentByPath,
-    claimedDeleted,
-    claimedNew
-  }));
-  const candidatesByNew = buildFrontmatterRenameCandidates({
-    deletedPaths,
-    newPaths,
-    priorByPath,
-    currentByPath,
-    claimedDeleted,
-    claimedNew
-  });
-  ops.push(...claimSingletonRenames({
-    newPaths,
-    candidatesByNew,
-    claimedDeleted,
-    claimedNew,
-    issues
-  }));
-  flagAmbiguousRenames({ newPaths, candidatesByNew, claimedDeleted, claimedNew, 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);
-}
+
+// kernel/orchestrator/node-build.ts
 function buildNode(args) {
   const bytesFrontmatter = Buffer.byteLength(args.frontmatterRaw, "utf8");
   const bytesBody = Buffer.byteLength(args.body, "utf8");
@@ -1943,171 +1770,72 @@ function resolveSidecarOverlay(relativePath, nodePathForIssue, roots, liveBodyHa
     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 resolveAbsoluteMdPath(relativePath, roots) {
-  if (isAbsolute3(relativePath)) {
-    return existsSync8(relativePath) ? relativePath : null;
-  }
-  for (const root of roots) {
-    const candidate = resolvePath(root, relativePath);
-    if (existsSync8(candidate)) return candidate;
-  }
-  return null;
-}
-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("/");
-    }
-  }
-  return absolutePath;
-}
-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 } : {}
-  };
-}
-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(", ")
-        })
-      })
-    );
-    return null;
-  }
-  const confidence = link.confidence ?? extractor.defaultConfidence;
-  return { ...link, confidence };
-}
-function validateFrontmatter(providerFrontmatter, provider, kind, frontmatter, path, strict) {
-  const result = providerFrontmatter.validate(provider, kind, frontmatter);
-  if (result.ok) return null;
-  return {
-    analyzerId: "frontmatter-invalid",
-    severity: strict ? "error" : "warn",
-    nodeIds: [path],
-    message: tx(ORCHESTRATOR_TEXTS.frontmatterInvalid, { path, kind, errors: result.errors }),
-    data: { kind, errors: result.errors }
-  };
-}
-function detectMalformedFrontmatter(body, path, strict) {
-  const hint = classifyMalformedFrontmatter(body);
-  if (!hint) return null;
-  return {
-    analyzerId: "frontmatter-malformed",
-    severity: strict ? "error" : "warn",
-    nodeIds: [path],
-    message: malformedMessage(hint, path),
-    data: { hint }
-  };
-}
-function classifyMalformedFrontmatter(body) {
-  if (body.startsWith("\uFEFF")) {
-    if (/^---\r?\n[\s\S]*?[A-Za-z0-9_-]+\s*:/.test(body)) {
-      return "byte-order-mark";
-    }
-  }
-  if (/^[ \t]+---\r?\n[ \t]*[A-Za-z0-9_-]+\s*:/.test(body)) {
-    return "paste-with-indent";
-  }
-  if (/^---\r?\n[ \t]*[A-Za-z0-9_-]+\s*:/.test(body)) {
-    const hasCloseFence = /\r?\n---(?:\r?\n|$)/.test(body);
-    if (!hasCloseFence) {
-      return "missing-close";
-    }
-  }
-  return null;
-}
-function malformedMessage(hint, path) {
-  switch (hint) {
-    case "paste-with-indent":
-      return tx(ORCHESTRATOR_TEXTS.frontmatterMalformedPasteWithIndent, { path });
-    case "byte-order-mark":
-      return tx(ORCHESTRATOR_TEXTS.frontmatterMalformedByteOrderMark, { path });
-    case "missing-close":
-      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;
-  }
-  return { ...issue, analyzerId: issue.analyzerId || analyzer.id };
+    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;
@@ -2127,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 resolve8, 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) => resolve8(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) => {