@skill-map/cli 0.7.0 → 0.9.0

package/dist/index.js

@@ -0,0 +1,1698 @@
+// kernel/i18n/registry.texts.ts
+var REGISTRY_TEXTS = {
+  duplicateExtension: "Extension already registered: {{kind}}:{{qualifiedId}}",
+  unknownKind: "Unknown extension kind: {{kind}}",
+  missingPluginId: "Extension {{kind}}:{{id}} is missing pluginId; built-ins declare it directly, user plugins have it injected by PluginLoader."
+};
+
+// kernel/util/tx.ts
+var TOKEN_RE = /\{\{\s*([A-Za-z][A-Za-z0-9_]*)\s*\}\}/g;
+function tx(template, vars = {}) {
+  return template.replace(TOKEN_RE, (_match, name) => {
+    if (!Object.prototype.hasOwnProperty.call(vars, name)) {
+      throw new Error(
+        `tx: missing variable "${name}" for template "${template.slice(0, 80)}${template.length > 80 ? "\u2026" : ""}"`
+      );
+    }
+    const value = vars[name];
+    if (value === null || value === void 0) {
+      throw new Error(
+        `tx: variable "${name}" is null/undefined for template "${template.slice(0, 80)}${template.length > 80 ? "\u2026" : ""}"`
+      );
+    }
+    return String(value);
+  });
+}
+
+// kernel/registry.ts
+var EXTENSION_KINDS = Object.freeze([
+  "provider",
+  "extractor",
+  "rule",
+  "action",
+  "formatter",
+  "hook"
+]);
+function qualifiedExtensionId(pluginId, id) {
+  return `${pluginId}/${id}`;
+}
+var DuplicateExtensionError = class extends Error {
+  constructor(kind, qualifiedId) {
+    super(tx(REGISTRY_TEXTS.duplicateExtension, { kind, qualifiedId }));
+    this.name = "DuplicateExtensionError";
+  }
+};
+var Registry = class {
+  /** kind → qualifiedId → Extension. */
+  #byKind;
+  constructor() {
+    this.#byKind = new Map(
+      EXTENSION_KINDS.map((k) => [k, /* @__PURE__ */ new Map()])
+    );
+  }
+  register(ext) {
+    const bucket = this.#byKind.get(ext.kind);
+    if (!bucket) {
+      throw new Error(tx(REGISTRY_TEXTS.unknownKind, { kind: ext.kind }));
+    }
+    if (typeof ext.pluginId !== "string" || ext.pluginId.length === 0) {
+      throw new Error(tx(REGISTRY_TEXTS.missingPluginId, { kind: ext.kind, id: ext.id }));
+    }
+    const key = qualifiedExtensionId(ext.pluginId, ext.id);
+    if (bucket.has(key)) {
+      throw new DuplicateExtensionError(ext.kind, key);
+    }
+    bucket.set(key, ext);
+  }
+  /**
+   * Lookup by qualified id (`<pluginId>/<id>`). Returns `undefined` when
+   * no extension of that kind is registered under the qualifier.
+   */
+  get(kind, qualifiedId) {
+    return this.#byKind.get(kind)?.get(qualifiedId);
+  }
+  /**
+   * Convenience wrapper that composes the qualified id for the caller.
+   * Equivalent to `get(kind, qualifiedExtensionId(pluginId, id))`.
+   */
+  find(kind, pluginId, id) {
+    return this.get(kind, qualifiedExtensionId(pluginId, id));
+  }
+  all(kind) {
+    const bucket = this.#byKind.get(kind);
+    return bucket ? [...bucket.values()] : [];
+  }
+  count(kind) {
+    return this.#byKind.get(kind)?.size ?? 0;
+  }
+  totalCount() {
+    let n = 0;
+    for (const bucket of this.#byKind.values()) n += bucket.size;
+    return n;
+  }
+};
+
+// kernel/orchestrator.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, statSync } from "fs";
+import { Tiktoken } from "js-tiktoken/lite";
+import cl100k_base from "js-tiktoken/ranks/cl100k_base";
+import yaml from "js-yaml";
+
+// package.json
+var package_default = {
+  name: "@skill-map/cli",
+  version: "0.9.0",
+  description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
+  license: "MIT",
+  type: "module",
+  homepage: "https://skill-map.dev",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/crystian/skill-map.git",
+    directory: "src"
+  },
+  bugs: {
+    url: "https://github.com/crystian/skill-map/issues"
+  },
+  keywords: [
+    "skill-map",
+    "markdown",
+    "ai-agents",
+    "claude-code",
+    "graph"
+  ],
+  bin: {
+    sm: "bin/sm.js",
+    "skill-map": "bin/sm.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./kernel": {
+      types: "./dist/kernel/index.d.ts",
+      import: "./dist/kernel/index.js"
+    },
+    "./conformance": {
+      types: "./dist/conformance/index.d.ts",
+      import: "./dist/conformance/index.js"
+    }
+  },
+  files: [
+    "bin/",
+    "dist/",
+    "migrations/",
+    "README.md"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    typecheck: "tsc --noEmit",
+    lint: "eslint .",
+    "lint:fix": "eslint . --fix",
+    test: "tsc --noEmit && node --import tsx --test --test-reporter=spec 'test/**/*.test.ts' 'built-in-plugins/**/*.test.ts' 'kernel/**/*.test.ts'",
+    "test:ci": "tsc --noEmit && node --import tsx --test 'test/**/*.test.ts' 'built-in-plugins/**/*.test.ts' 'kernel/**/*.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'",
+    "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'",
+    clean: "rm -rf dist coverage"
+  },
+  dependencies: {
+    "@skill-map/spec": "*",
+    ajv: "8.18.0",
+    "ajv-formats": "3.0.1",
+    chokidar: "5.0.0",
+    clipanion: "4.0.0-rc.4",
+    ignore: "7.0.5",
+    "js-tiktoken": "1.0.21",
+    "js-yaml": "4.1.1",
+    kysely: "0.28.16",
+    semver: "7.7.4",
+    typanion: "3.14.0"
+  },
+  devDependencies: {
+    "@eslint/js": "10.0.1",
+    "@stylistic/eslint-plugin": "5.10.0",
+    "@types/js-yaml": "4.0.9",
+    "@types/node": "24.12.2",
+    "@types/semver": "7.7.1",
+    c8: "11.0.0",
+    eslint: "10.2.1",
+    "eslint-plugin-import-x": "4.16.2",
+    tsup: "8.5.1",
+    tsx: "4.21.0",
+    typescript: "5.9.3",
+    "typescript-eslint": "8.59.1"
+  },
+  engines: {
+    node: ">=24.0"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// 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() {
+  }
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+};
+
+// kernel/util/logger.ts
+var active = new SilentLogger();
+var log = {
+  trace: (message, context) => active.trace(message, context),
+  debug: (message, context) => active.debug(message, context),
+  info: (message, context) => active.info(message, context),
+  warn: (message, context) => active.warn(message, context),
+  error: (message, context) => active.error(message, context)
+};
+function configureLogger(impl) {
+  active = impl;
+}
+function resetLogger() {
+  active = new SilentLogger();
+}
+function getActiveLogger() {
+  return active;
+}
+
+// kernel/adapters/plugin-loader.ts
+import { createRequire } from "module";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { isAbsolute, join, relative, resolve } from "path";
+import { pathToFileURL } from "url";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import addFormatsModule from "ajv-formats";
+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);
+    }
+  };
+}
+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 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 formatAjvErrors(errors) {
+  if (!errors || errors.length === 0) return "(no AJV details)";
+  return errors.map((e) => `${e.instancePath || "(root)"} ${e.message ?? e.keyword}`).join("; ");
+}
+
+// kernel/extensions/hook.ts
+var HOOK_TRIGGERS = Object.freeze([
+  "scan.started",
+  "scan.completed",
+  "extractor.completed",
+  "rule.completed",
+  "action.completed",
+  "job.spawning",
+  "job.completed",
+  "job.failed"
+]);
+
+// kernel/adapters/plugin-loader.ts
+var addFormats = addFormatsModule.default ?? addFormatsModule;
+var KNOWN_KINDS = /* @__PURE__ */ new Set(["provider", "extractor", "rule", "action", "formatter", "hook"]);
+var KNOWN_KINDS_LIST = [...KNOWN_KINDS].join(" / ");
+var HOOKABLE_TRIGGERS_LIST = HOOK_TRIGGERS.join(", ");
+function installedSpecVersion() {
+  const require2 = createRequire(import.meta.url);
+  const indexPath = require2.resolve("@skill-map/spec/index.json");
+  const pkgPath = resolve(indexPath, "..", "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  return pkg.version;
+}
+
+// kernel/adapters/schema-validators.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { createRequire as createRequire2 } from "module";
+import { Ajv2020 as Ajv20202 } from "ajv/dist/2020.js";
+import addFormatsModule2 from "ajv-formats";
+var addFormats2 = addFormatsModule2.default ?? addFormatsModule2;
+function buildProviderFrontmatterValidator(providers) {
+  const specRoot = resolveSpecRoot();
+  const ajv = new Ajv20202({
+    strict: false,
+    allErrors: true,
+    allowUnionTypes: true
+  });
+  addFormats2(ajv);
+  const baseFile = resolve2(specRoot, "schemas/frontmatter/base.schema.json");
+  const baseSchema = JSON.parse(readFileSync2(baseFile, "utf8"));
+  ajv.addSchema(baseSchema);
+  const compiled = /* @__PURE__ */ new Map();
+  for (const provider of providers) {
+    for (const [kind, entry] of Object.entries(provider.kinds)) {
+      const key = `${provider.id}::${kind}`;
+      const json = entry.schemaJson;
+      const existing = typeof json.$id === "string" ? ajv.getSchema(json.$id) : void 0;
+      compiled.set(key, existing ?? ajv.compile(entry.schemaJson));
+    }
+  }
+  return {
+    validate(provider, kind, data) {
+      const key = `${provider.id}::${kind}`;
+      const v = compiled.get(key);
+      if (!v) return { ok: false, errors: "no-schema" };
+      if (v(data)) return { ok: true };
+      const errors = (v.errors ?? []).map(formatError).join("; ");
+      return { ok: false, errors };
+    }
+  };
+}
+function formatError(err) {
+  const path = err.instancePath || "(root)";
+  return `${path} ${err.message ?? err.keyword}`;
+}
+function resolveSpecRoot() {
+  const require2 = createRequire2(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 ensure the workspace is linked or the package is installed."
+    );
+  }
+}
+
+// kernel/i18n/orchestrator.texts.ts
+var ORCHESTRATOR_TEXTS = {
+  frontmatterInvalid: "Frontmatter for {{path}} ({{kind}}) failed schema validation: {{errors}}",
+  frontmatterMalformedPasteWithIndent: "Frontmatter fence in {{path}} appears indented; YAML frontmatter MUST start with `---` at column 0. The file was scanned as body-only \u2014 the metadata block was silently lost. Move the `---` lines to the start of the line.",
+  frontmatterMalformedByteOrderMark: "Frontmatter fence in {{path}} is preceded by a UTF-8 byte-order mark (BOM); the file was scanned as body-only. Re-save the file as UTF-8 without BOM. The metadata block was silently lost.",
+  frontmatterMalformedMissingClose: "Frontmatter in {{path}} opens with `---` but never closes \u2014 no matching `---` line at column 0 was found. The file was scanned as body-only and every metadata field was silently lost. Add a closing `---` line below the metadata block.",
+  extensionErrorLinkKindNotDeclared: 'Extractor "{{extractorId}}" emitted a link of kind "{{linkKind}}" outside its declared `emitsLinkKinds` set [{{declaredKinds}}]. Link dropped.',
+  extensionErrorIssueInvalidSeverity: `Rule "{{ruleId}}" emitted an issue with invalid severity {{severity}} (allowed: 'error' | 'warn' | 'info'). Issue dropped.`,
+  runScanRootEmptyArray: "runScan: roots must contain at least one path (spec requires minItems: 1)",
+  runScanRootMissing: "runScan: root path '{{root}}' does not exist or is not a directory"
+};
+
+// kernel/orchestrator.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 start = Date.now();
+  const scannedAt = start;
+  const emitter = options.emitter ?? new InMemoryProgressEmitter();
+  const exts = options.extensions ?? { providers: [], extractors: [], rules: [] };
+  const hookDispatcher = makeHookDispatcher(exts.hooks ?? [], emitter);
+  const tokenize = options.tokenize !== false;
+  const scope = options.scope ?? "project";
+  const strict = options.strict === true;
+  const encoder = tokenize ? new Tiktoken(cl100k_base) : null;
+  const prior = options.priorSnapshot ?? null;
+  const enableCache = options.enableCache === true;
+  const priorExtractorRuns = options.priorExtractorRuns;
+  const priorIndex = indexPriorSnapshot(prior);
+  const providerFrontmatter = buildProviderFrontmatterValidator(exts.providers);
+  const scanStartedEvent = makeEvent("scan.started", { roots: options.roots });
+  emitter.emit(scanStartedEvent);
+  await hookDispatcher.dispatch("scan.started", scanStartedEvent);
+  const walked = await walkAndExtract({
+    providers: exts.providers,
+    extractors: exts.extractors,
+    roots: options.roots,
+    ...options.ignoreFilter ? { ignoreFilter: options.ignoreFilter } : {},
+    emitter,
+    encoder,
+    strict,
+    enableCache,
+    prior,
+    priorIndex,
+    priorExtractorRuns,
+    providerFrontmatter,
+    pluginStores: options.pluginStores
+  });
+  recomputeLinkCounts(walked.nodes, walked.internalLinks);
+  recomputeExternalRefsCount(walked.nodes, walked.externalLinks, walked.cachedPaths);
+  for (const extractor of exts.extractors) {
+    const extractorId = qualifiedExtensionId(extractor.pluginId, extractor.id);
+    const evt = makeEvent("extractor.completed", { extractorId });
+    emitter.emit(evt);
+    await hookDispatcher.dispatch("extractor.completed", evt);
+  }
+  const issues = await runRules(exts.rules, walked.nodes, walked.internalLinks, emitter, hookDispatcher);
+  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
+    // `'note'`), 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
+  };
+}
+function validateRoots(roots) {
+  if (roots.length === 0) {
+    throw new Error(ORCHESTRATOR_TEXTS.runScanRootEmptyArray);
+  }
+  for (const root of roots) {
+    if (!existsSync2(root) || !statSync(root).isDirectory()) {
+      throw new Error(tx(ORCHESTRATOR_TEXTS.runScanRootMissing, { root }));
+    }
+  }
+}
+function indexPriorSnapshot(prior) {
+  const priorNodesByPath = /* @__PURE__ */ new Map();
+  const priorNodePaths = /* @__PURE__ */ new Set();
+  const priorLinksByOriginating = /* @__PURE__ */ new Map();
+  const priorFrontmatterIssuesByNode = /* @__PURE__ */ new Map();
+  if (!prior) {
+    return { priorNodesByPath, priorNodePaths, priorLinksByOriginating, priorFrontmatterIssuesByNode };
+  }
+  for (const node of prior.nodes) {
+    priorNodesByPath.set(node.path, node);
+    priorNodePaths.add(node.path);
+  }
+  for (const link of prior.links) {
+    const key = originatingNodeOf(link, priorNodePaths);
+    const list = priorLinksByOriginating.get(key);
+    if (list) list.push(link);
+    else priorLinksByOriginating.set(key, [link]);
+  }
+  for (const issue of prior.issues) {
+    if (issue.ruleId !== "frontmatter-invalid" && issue.ruleId !== "frontmatter-malformed") continue;
+    if (issue.nodeIds.length !== 1) continue;
+    const path = issue.nodeIds[0];
+    const list = priorFrontmatterIssuesByNode.get(path);
+    if (list) list.push(issue);
+    else priorFrontmatterIssuesByNode.set(path, [issue]);
+  }
+  return { priorNodesByPath, priorNodePaths, priorLinksByOriginating, priorFrontmatterIssuesByNode };
+}
+async function runExtractorsForNode(opts) {
+  const internalLinks = [];
+  const externalLinks = [];
+  const enrichmentBuffer = /* @__PURE__ */ new Map();
+  for (const extractor of opts.extractors) {
+    const qualifiedId = qualifiedExtensionId(extractor.pluginId, extractor.id);
+    const isProb = extractor.mode === "probabilistic";
+    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(),
+          isProbabilistic: isProb
+        });
+      }
+    };
+    const store = opts.pluginStores?.get(extractor.pluginId);
+    const ctx = buildExtractorContext(
+      extractor,
+      opts.node,
+      opts.body,
+      opts.frontmatter,
+      emitLink,
+      enrichNode,
+      store
+    );
+    await extractor.extract(ctx);
+  }
+  return {
+    internalLinks,
+    externalLinks,
+    enrichments: Array.from(enrichmentBuffer.values())
+  };
+}
+function computeCacheDecision(opts) {
+  const applicableExtractors = opts.extractors.filter(
+    (ex) => ex.applicableKinds === void 0 || ex.applicableKinds.includes(opts.kind)
+  );
+  const applicableQualifiedIds = new Set(
+    applicableExtractors.map((ex) => qualifiedExtensionId(ex.pluginId, ex.id))
+  );
+  const cachedQualifiedIds = /* @__PURE__ */ new Set();
+  const missingExtractors = [];
+  if (opts.priorExtractorRuns === void 0) {
+    if (opts.nodeHashCacheEligible) {
+      for (const id of applicableQualifiedIds) cachedQualifiedIds.add(id);
+    } else {
+      for (const ex of applicableExtractors) missingExtractors.push(ex);
+    }
+  } else {
+    const priorRunsForNode = opts.priorExtractorRuns.get(opts.nodePath) ?? /* @__PURE__ */ new Map();
+    for (const ex of applicableExtractors) {
+      const qualified = qualifiedExtensionId(ex.pluginId, ex.id);
+      const priorBody = priorRunsForNode.get(qualified);
+      if (opts.nodeHashCacheEligible && priorBody === opts.bodyHash) {
+        cachedQualifiedIds.add(qualified);
+      } else {
+        missingExtractors.push(ex);
+      }
+    }
+  }
+  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);
+  }
+  const frontmatterIssues = [];
+  const reusedFm = opts.priorFrontmatterIssuesByNode.get(opts.priorNode.path) ?? [];
+  for (const issue of reusedFm) {
+    frontmatterIssues.push({ ...issue, severity: opts.strict ? "error" : "warn" });
+  }
+  return { node, internalLinks, frontmatterIssues };
+}
+function reusePriorNode(opts) {
+  const base = cloneNodeAndReshapeLinks(opts);
+  const ranAt = Date.now();
+  const extractorRuns = [];
+  for (const qualified of opts.cachedQualifiedIds) {
+    extractorRuns.push({
+      nodePath: opts.priorNode.path,
+      extractorId: qualified,
+      bodyHashAtRun: opts.bodyHash,
+      ranAt
+    });
+  }
+  return { ...base, extractorRuns };
+}
+function buildFreshNodeAndValidateFrontmatter(opts) {
+  const node = buildNode({
+    path: opts.raw.path,
+    kind: opts.kind,
+    providerId: opts.provider.id,
+    frontmatterRaw: opts.raw.frontmatterRaw,
+    body: opts.raw.body,
+    frontmatter: opts.raw.frontmatter,
+    bodyHash: opts.bodyHash,
+    frontmatterHash: opts.frontmatterHash,
+    encoder: opts.encoder
+  });
+  const frontmatterIssues = [];
+  if (opts.raw.frontmatterRaw.length > 0) {
+    const fmIssue = validateFrontmatter(
+      opts.providerFrontmatter,
+      opts.provider,
+      opts.kind,
+      opts.raw.frontmatter,
+      opts.raw.path,
+      opts.strict
+    );
+    if (fmIssue) frontmatterIssues.push(fmIssue);
+  } else {
+    const malformed = detectMalformedFrontmatter(opts.raw.body, opts.raw.path, opts.strict);
+    if (malformed) frontmatterIssues.push(malformed);
+  }
+  return { node, frontmatterIssues };
+}
+async function walkAndExtract(opts) {
+  const {
+    providers,
+    extractors,
+    roots,
+    ignoreFilter,
+    emitter,
+    encoder,
+    strict,
+    enableCache,
+    prior,
+    priorIndex,
+    priorExtractorRuns,
+    providerFrontmatter,
+    pluginStores
+  } = opts;
+  const { priorNodesByPath, priorLinksByOriginating, priorFrontmatterIssuesByNode } = priorIndex;
+  const nodes = [];
+  const internalLinks = [];
+  const externalLinks = [];
+  const cachedPaths = /* @__PURE__ */ new Set();
+  const frontmatterIssues = [];
+  const enrichmentBuffer = /* @__PURE__ */ new Map();
+  const extractorRuns = [];
+  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]);
+  }
+  for (const provider of providers) {
+    for await (const raw of provider.walk(roots, walkOptions)) {
+      filesWalked += 1;
+      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);
+      index += 1;
+      const cacheDecision = computeCacheDecision({
+        extractors,
+        kind,
+        nodePath: raw.path,
+        bodyHash,
+        nodeHashCacheEligible,
+        priorExtractorRuns
+      });
+      const {
+        applicableExtractors,
+        applicableQualifiedIds,
+        cachedQualifiedIds,
+        missingExtractors,
+        fullCacheHit
+      } = cacheDecision;
+      if (fullCacheHit && priorNode) {
+        const reused = reusePriorNode({
+          priorNode,
+          bodyHash,
+          strict,
+          cachedQualifiedIds,
+          applicableQualifiedIds,
+          shortIdToQualified,
+          priorLinksByOriginating,
+          priorFrontmatterIssuesByNode
+        });
+        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 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);
+      }
+      emitter.emit(makeEvent("scan.progress", {
+        index,
+        path: raw.path,
+        kind,
+        cached: false,
+        ...partialCacheHit ? { partialCache: true } : {}
+      }));
+      const extractorsToRun = partialCacheHit ? missingExtractors : applicableExtractors;
+      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);
+      }
+      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
+        });
+      }
+    }
+  }
+  return {
+    nodes,
+    internalLinks,
+    externalLinks,
+    cachedPaths,
+    frontmatterIssues,
+    filesWalked,
+    enrichments: [...enrichmentBuffer.values()],
+    extractorRuns
+  };
+}
+function reuseCachedLink(link, shortIdToQualified, cachedQualifiedIds, applicableQualifiedIds) {
+  if (!Array.isArray(link.sources) || link.sources.length === 0) return null;
+  const cachedSources = [];
+  const obsoleteSources = [];
+  let hasMissing = false;
+  for (const source of link.sources) {
+    const candidates = shortIdToQualified.get(source);
+    if (!candidates || candidates.length === 0) {
+      obsoleteSources.push(source);
+      continue;
+    }
+    if (candidates.some((q) => cachedQualifiedIds.has(q))) {
+      cachedSources.push(source);
+      continue;
+    }
+    if (candidates.some((q) => applicableQualifiedIds.has(q))) {
+      hasMissing = true;
+      continue;
+    }
+    obsoleteSources.push(source);
+  }
+  if (hasMissing) return null;
+  if (cachedSources.length === 0) return null;
+  if (obsoleteSources.length === 0) return link;
+  return { ...link, sources: cachedSources };
+}
+async function runRules(rules, nodes, internalLinks, emitter, hookDispatcher) {
+  const issues = [];
+  for (const rule of rules) {
+    const emitted = await rule.evaluate({ nodes, links: internalLinks });
+    for (const issue of emitted) {
+      const validated = validateIssue(rule, issue, emitter);
+      if (validated) issues.push(validated);
+    }
+    const ruleId = qualifiedExtensionId(rule.pluginId, rule.id);
+    const evt = makeEvent("rule.completed", { ruleId });
+    emitter.emit(evt);
+    await hookDispatcher.dispatch("rule.completed", evt);
+  }
+  return issues;
+}
+function originatingNodeOf(link, priorNodePaths) {
+  if (link.kind === "supersedes" && !priorNodePaths.has(link.source)) {
+    return link.target;
+  }
+  return link.source;
+}
+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;
+      }
+    }
+  }
+  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);
+  }
+  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({
+        ruleId: "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 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({
+        ruleId: "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 }
+      });
+    }
+  }
+}
+function flagOrphans(opts) {
+  for (const fromPath of opts.deletedPaths) {
+    if (opts.claimedDeleted.has(fromPath)) continue;
+    opts.issues.push({
+      ruleId: "orphan",
+      severity: "info",
+      nodeIds: [fromPath],
+      message: `Orphan history: ${fromPath} was deleted; no rename match found.`,
+      data: { path: fromPath }
+    });
+  }
+}
+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);
+}
+function makeEvent(type, data) {
+  return { type, timestamp: (/* @__PURE__ */ new Date()).toISOString(), data };
+}
+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;
+    }
+    for (const trig of hook.triggers) {
+      const bucket = byTrigger.get(trig);
+      if (bucket) bucket.push(hook);
+      else byTrigger.set(trig, [hook]);
+    }
+  }
+  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 = err instanceof Error ? err.message : String(err);
+          emitter.emit(
+            makeEvent("extension.error", {
+              kind: "hook-error",
+              extensionId: qualifiedId,
+              trigger,
+              message
+            })
+          );
+        }
+      }
+    }
+  };
+}
+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;
+}
+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["ruleId"] === "string") ctx.ruleId = data["ruleId"];
+  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;
+}
+function buildNode(args) {
+  const bytesFrontmatter = Buffer.byteLength(args.frontmatterRaw, "utf8");
+  const bytesBody = Buffer.byteLength(args.body, "utf8");
+  const metadata = pickMetadata(args.frontmatter);
+  const node = {
+    path: args.path,
+    kind: args.kind,
+    provider: args.providerId,
+    bodyHash: args.bodyHash,
+    frontmatterHash: args.frontmatterHash,
+    bytes: {
+      frontmatter: bytesFrontmatter,
+      body: bytesBody,
+      total: bytesFrontmatter + bytesBody
+    },
+    linksOutCount: 0,
+    linksInCount: 0,
+    externalRefsCount: 0,
+    frontmatter: args.frontmatter,
+    title: pickString(args.frontmatter["name"]),
+    description: pickString(args.frontmatter["description"]),
+    stability: pickStability(metadata?.["stability"]),
+    version: pickString(metadata?.["version"]),
+    author: pickString(args.frontmatter["author"])
+  };
+  if (args.encoder) {
+    node.tokens = countTokens(args.encoder, args.frontmatterRaw, args.body);
+  }
+  return node;
+}
+function countTokens(encoder, frontmatterRaw, body) {
+  const frontmatter = frontmatterRaw.length > 0 ? encoder.encode(frontmatterRaw).length : 0;
+  const bodyTokens = body.length > 0 ? encoder.encode(body).length : 0;
+  return { frontmatter, body: bodyTokens, total: frontmatter + bodyTokens };
+}
+function sha256(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+function canonicalFrontmatter(parsed, raw) {
+  const hasParsedKeys = Object.keys(parsed).length > 0;
+  const hasRawText = raw.length > 0;
+  if (!hasParsedKeys && hasRawText) {
+    return raw;
+  }
+  return yaml.dump(parsed, {
+    sortKeys: true,
+    lineWidth: -1,
+    noRefs: true,
+    noCompatMode: true
+  });
+}
+function pickMetadata(fm) {
+  const m = fm["metadata"];
+  return m && typeof m === "object" && !Array.isArray(m) ? m : null;
+}
+function pickString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function pickStability(value) {
+  if (value === "experimental" || value === "stable" || value === "deprecated") return value;
+  return null;
+}
+function buildExtractorContext(extractor, node, body, frontmatter, emitLink, enrichNode, store) {
+  const scope = extractor.scope;
+  return {
+    node,
+    body: scope === "frontmatter" ? "" : body,
+    frontmatter: scope === "body" ? {} : frontmatter,
+    emitLink,
+    enrichNode,
+    ...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 {
+    ruleId: "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 {
+    ruleId: "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(rule, issue, emitter) {
+  const severity = issue.severity;
+  if (severity !== "error" && severity !== "warn" && severity !== "info") {
+    const qualifiedId = `${rule.pluginId}/${rule.id}`;
+    emitter.emit(
+      makeEvent("extension.error", {
+        kind: "issue-invalid-severity",
+        extensionId: qualifiedId,
+        severity,
+        issue: { ruleId: issue.ruleId || rule.id, message: issue.message, nodeIds: issue.nodeIds },
+        message: tx(ORCHESTRATOR_TEXTS.extensionErrorIssueInvalidSeverity, {
+          ruleId: qualifiedId,
+          severity: JSON.stringify(severity)
+        })
+      })
+    );
+    return null;
+  }
+  return { ...issue, ruleId: issue.ruleId || rule.id };
+}
+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);
+  }
+  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;
+  }
+}
+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 link of externalLinks) {
+    const source = byPath2.get(link.source);
+    if (source && !cachedPaths.has(source.path)) source.externalRefsCount += 1;
+  }
+}
+function mergeNodeWithEnrichments(node, enrichments, opts = {}) {
+  const includeStale = opts.includeStale === true;
+  const applicable = enrichments.filter((e) => e.nodePath === node.path).filter((e) => includeStale || !e.stale).sort((a, b) => a.enrichedAt - b.enrichedAt);
+  const base = {};
+  assignSafe(base, node.frontmatter ?? {});
+  for (const row of applicable) {
+    assignSafe(base, row.value);
+  }
+  return base;
+}
+var FORBIDDEN_MERGE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function assignSafe(target, source) {
+  for (const [k, v] of Object.entries(source)) {
+    if (FORBIDDEN_MERGE_KEYS.has(k)) continue;
+    target[k] = v;
+  }
+}
+
+// kernel/scan/watcher.ts
+import { resolve as resolve3, relative as relative2, sep } from "path";
+import chokidar from "chokidar";
+function createChokidarWatcher(opts) {
+  const absRoots = opts.roots.map((r) => resolve3(opts.cwd, r));
+  const ignoreFilter = opts.ignoreFilter;
+  const ignored = ignoreFilter ? (path) => {
+    const rel = relativePathFromRoots(path, absRoots);
+    if (rel === null) return false;
+    return ignoreFilter.ignores(rel);
+  } : void 0;
+  const watcher = chokidar.watch(absRoots, {
+    ignoreInitial: true,
+    persistent: true,
+    ...ignored ? { ignored } : {}
+  });
+  let pending = [];
+  let timer = null;
+  let inFlight = null;
+  let closed = false;
+  const fire = async () => {
+    timer = null;
+    if (pending.length === 0) return;
+    if (inFlight) {
+      return;
+    }
+    const events = pending;
+    pending = [];
+    const seen = /* @__PURE__ */ new Set();
+    const paths = [];
+    for (const ev of events) {
+      if (!seen.has(ev.absolutePath)) {
+        seen.add(ev.absolutePath);
+        paths.push(ev.absolutePath);
+      }
+    }
+    inFlight = Promise.resolve(opts.onBatch({ events, paths })).catch((err) => {
+      if (opts.onError) {
+        opts.onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    }).finally(() => {
+      inFlight = null;
+      if (!closed && pending.length > 0 && timer === null) {
+        schedule();
+      }
+    });
+  };
+  const schedule = () => {
+    if (closed) return;
+    if (opts.debounceMs <= 0) {
+      void fire();
+      return;
+    }
+    if (timer !== null) clearTimeout(timer);
+    timer = setTimeout(() => {
+      void fire();
+    }, opts.debounceMs);
+  };
+  const enqueue = (kind, absolutePath) => {
+    if (closed) return;
+    pending.push({ kind, absolutePath });
+    schedule();
+  };
+  watcher.on("add", (p) => enqueue("add", p));
+  watcher.on("change", (p) => enqueue("change", p));
+  watcher.on("unlink", (p) => enqueue("unlink", p));
+  if (opts.onError) {
+    watcher.on("error", (err) => {
+      opts.onError?.(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+  const ready = new Promise((resolveReady) => {
+    watcher.once("ready", () => resolveReady());
+  });
+  const close = async () => {
+    closed = true;
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    pending = [];
+    if (inFlight) {
+      try {
+        await inFlight;
+      } catch {
+      }
+    }
+    await watcher.close();
+  };
+  return { ready, close };
+}
+function relativePathFromRoots(absolute, absRoots) {
+  for (const root of absRoots) {
+    const rel = relative2(root, absolute);
+    if (rel === "" || rel === ".") return "";
+    if (!rel.startsWith("..") && !rel.startsWith(`..${sep}`)) {
+      return rel.split(sep).join("/");
+    }
+  }
+  return null;
+}
+
+// kernel/scan/delta.ts
+function computeScanDelta(prior, current, comparedWith) {
+  return {
+    comparedWith,
+    nodes: diffNodes(prior.nodes, current.nodes),
+    links: diffLinks(prior.links, current.links),
+    issues: diffIssues(prior.issues, current.issues)
+  };
+}
+function isEmptyDelta(delta) {
+  return delta.nodes.added.length === 0 && delta.nodes.removed.length === 0 && delta.nodes.changed.length === 0 && delta.links.added.length === 0 && delta.links.removed.length === 0 && delta.issues.added.length === 0 && delta.issues.removed.length === 0;
+}
+function diffNodes(priorNodes, currentNodes) {
+  const priorByPath = new Map(priorNodes.map((n) => [n.path, n]));
+  const currentByPath = new Map(currentNodes.map((n) => [n.path, n]));
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [path, after] of currentByPath) {
+    const before = priorByPath.get(path);
+    if (!before) {
+      added.push(after);
+      continue;
+    }
+    const reason = compareNodeHashes(before, after);
+    if (reason !== null) changed.push({ before, after, reason });
+  }
+  for (const [path, before] of priorByPath) {
+    if (!currentByPath.has(path)) removed.push(before);
+  }
+  added.sort(byPath);
+  removed.sort(byPath);
+  changed.sort((a, b) => byPath(a.after, b.after));
+  return { added, removed, changed };
+}
+function compareNodeHashes(before, after) {
+  const bodyChanged = before.bodyHash !== after.bodyHash;
+  const fmChanged = before.frontmatterHash !== after.frontmatterHash;
+  if (bodyChanged && fmChanged) return "both";
+  if (bodyChanged) return "body";
+  if (fmChanged) return "frontmatter";
+  return null;
+}
+function byPath(a, b) {
+  return a.path.localeCompare(b.path);
+}
+function diffLinks(priorLinks, currentLinks) {
+  const priorKeys = new Set(priorLinks.map(linkIdentity));
+  const currentKeys = new Set(currentLinks.map(linkIdentity));
+  const added = [];
+  const removed = [];
+  for (const link of currentLinks) {
+    if (!priorKeys.has(linkIdentity(link))) added.push(link);
+  }
+  for (const link of priorLinks) {
+    if (!currentKeys.has(linkIdentity(link))) removed.push(link);
+  }
+  added.sort(byLinkSort);
+  removed.sort(byLinkSort);
+  return { added, removed };
+}
+function linkIdentity(link) {
+  const trigger = link.trigger?.normalizedTrigger ?? "";
+  return `${link.source}\0${link.target}\0${link.kind}\0${trigger}`;
+}
+function byLinkSort(a, b) {
+  if (a.source !== b.source) return a.source.localeCompare(b.source);
+  if (a.target !== b.target) return a.target.localeCompare(b.target);
+  return a.kind.localeCompare(b.kind);
+}
+function diffIssues(priorIssues, currentIssues) {
+  const priorKeys = new Set(priorIssues.map(issueIdentity));
+  const currentKeys = new Set(currentIssues.map(issueIdentity));
+  const added = [];
+  const removed = [];
+  for (const issue of currentIssues) {
+    if (!priorKeys.has(issueIdentity(issue))) added.push(issue);
+  }
+  for (const issue of priorIssues) {
+    if (!currentKeys.has(issueIdentity(issue))) removed.push(issue);
+  }
+  added.sort(byIssueSort);
+  removed.sort(byIssueSort);
+  return { added, removed };
+}
+function issueIdentity(issue) {
+  const ids = [...issue.nodeIds].sort().join(",");
+  return `${issue.ruleId}\0${ids}\0${issue.message}`;
+}
+function byIssueSort(a, b) {
+  if (a.ruleId !== b.ruleId) return a.ruleId.localeCompare(b.ruleId);
+  return a.message.localeCompare(b.message);
+}
+
+// kernel/i18n/storage.texts.ts
+var QUERY_TEXTS = {
+  exportQueryInvalidToken: 'invalid token "{{token}}": expected key=value (e.g. kind=skill, has=issues, path=foo/*).',
+  exportQueryDuplicateKey: 'key "{{key}}" appears more than once; combine values with a comma instead (e.g. kind=skill,agent).',
+  exportQueryEmptyValues: 'key "{{key}}" has no values.',
+  exportQueryUnknownKey: 'unknown key "{{key}}". Valid keys: kind, has, path.',
+  exportQueryEmptyKind: 'kind="" is not a valid node kind (empty).',
+  exportQueryUnsupportedHas: 'has="{{value}}" is not supported. Valid: {{allowed}}. (findings / summary land at Steps 10 / 11.)'
+};
+
+// kernel/scan/query.ts
+var HAS_VALUES = /* @__PURE__ */ new Set(["issues"]);
+var ExportQueryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ExportQueryError";
+  }
+};
+function parseExportQuery(raw) {
+  const trimmed = raw.trim();
+  const out = { raw: trimmed };
+  if (trimmed.length === 0) return out;
+  const seen = /* @__PURE__ */ new Set();
+  for (const token of trimmed.split(/\s+/)) {
+    const eq = token.indexOf("=");
+    if (eq <= 0 || eq === token.length - 1) {
+      throw new ExportQueryError(
+        tx(QUERY_TEXTS.exportQueryInvalidToken, { token })
+      );
+    }
+    const key = token.slice(0, eq).toLowerCase();
+    const valuePart = token.slice(eq + 1);
+    if (seen.has(key)) {
+      throw new ExportQueryError(
+        tx(QUERY_TEXTS.exportQueryDuplicateKey, { key })
+      );
+    }
+    seen.add(key);
+    const values = valuePart.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
+    if (values.length === 0) {
+      throw new ExportQueryError(tx(QUERY_TEXTS.exportQueryEmptyValues, { key }));
+    }
+    switch (key) {
+      case "kind":
+        out.kinds = parseKindValues(values);
+        break;
+      case "has":
+        if (parseHasValues(values)) out.hasIssues = true;
+        break;
+      case "path":
+        out.pathGlobs = values;
+        break;
+      default:
+        throw new ExportQueryError(
+          tx(QUERY_TEXTS.exportQueryUnknownKey, { key })
+        );
+    }
+  }
+  return out;
+}
+function parseKindValues(values) {
+  for (const v of values) {
+    if (v.length === 0) {
+      throw new ExportQueryError(QUERY_TEXTS.exportQueryEmptyKind);
+    }
+  }
+  return values;
+}
+function parseHasValues(values) {
+  for (const v of values) {
+    if (!HAS_VALUES.has(v)) {
+      throw new ExportQueryError(
+        tx(QUERY_TEXTS.exportQueryUnsupportedHas, {
+          value: v,
+          allowed: [...HAS_VALUES].join(", ")
+        })
+      );
+    }
+  }
+  return values.includes("issues");
+}
+function applyExportQuery(scan, query) {
+  const nodesWithIssues = query.hasIssues ? collectNodesWithIssues(scan.issues) : null;
+  const compiledGlobs = query.pathGlobs ? query.pathGlobs.map(compileGlob) : null;
+  const filteredNodes = scan.nodes.filter((node) => {
+    if (query.kinds && !query.kinds.includes(node.kind)) return false;
+    if (nodesWithIssues && !nodesWithIssues.has(node.path)) return false;
+    if (compiledGlobs && !compiledGlobs.some((re) => re.test(node.path))) return false;
+    return true;
+  });
+  const survivingPaths = new Set(filteredNodes.map((n) => n.path));
+  const filteredLinks = scan.links.filter(
+    (link) => survivingPaths.has(link.source) && survivingPaths.has(link.target)
+  );
+  const filteredIssues = scan.issues.filter(
+    (issue) => issue.nodeIds.some((id) => survivingPaths.has(id))
+  );
+  return {
+    query,
+    nodes: filteredNodes,
+    links: filteredLinks,
+    issues: filteredIssues
+  };
+}
+function collectNodesWithIssues(issues) {
+  const out = /* @__PURE__ */ new Set();
+  for (const issue of issues) {
+    for (const nodeId of issue.nodeIds) out.add(nodeId);
+  }
+  return out;
+}
+function compileGlob(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const withDouble = escaped.replace(/\*\*/g, "\0DOUBLESTAR\0");
+  const withSingle = withDouble.replace(/\*/g, "[^/]*");
+  const final = withSingle.replace(/DOUBLESTAR/g, ".*");
+  return new RegExp(`^${final}$`);
+}
+
+// kernel/ports/logger.ts
+var LOG_LEVELS = [
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "silent"
+];
+var LEVEL_RANK = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  silent: 5
+};
+function logLevelRank(level) {
+  return LEVEL_RANK[level];
+}
+function isLogLevel(value) {
+  return typeof value === "string" && Object.prototype.hasOwnProperty.call(LEVEL_RANK, value);
+}
+function parseLogLevel(value) {
+  if (value === void 0 || value === null) return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "") return null;
+  return isLogLevel(normalized) ? normalized : null;
+}
+
+// kernel/index.ts
+function createKernel() {
+  return { registry: new Registry() };
+}
+export {
+  DuplicateExtensionError,
+  EXTENSION_KINDS,
+  ExportQueryError,
+  HOOK_TRIGGERS,
+  InMemoryProgressEmitter,
+  KV_SCHEMA_KEY,
+  LOG_LEVELS,
+  Registry,
+  SilentLogger,
+  applyExportQuery,
+  computeScanDelta,
+  configureLogger,
+  createChokidarWatcher,
+  createKernel,
+  detectRenamesAndOrphans,
+  getActiveLogger,
+  isEmptyDelta,
+  isLogLevel,
+  log,
+  logLevelRank,
+  makeDedicatedStoreWrapper,
+  makeKvStoreWrapper,
+  makePluginStore,
+  mergeNodeWithEnrichments,
+  parseExportQuery,
+  parseLogLevel,
+  qualifiedExtensionId,
+  resetLogger,
+  runExtractorsForNode,
+  runScan,
+  runScanWithRenames
+};
+//# sourceMappingURL=index.js.map