@skill-map/cli 0.56.0 → 0.57.0

package/dist/kernel/index.js

@@ -1,6 +1,6 @@
 // kernel/i18n/registry.texts.ts
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bed984e8-cc93-51f3-94cd-c0789fe21577")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="12d40092-5030-5aa9-ba9b-939af94ed740")}catch(e){}}();
 var REGISTRY_TEXTS = {
   duplicateExtension: "Extension already registered: {{kind}}:{{qualifiedId}}",
   unknownKind: "Unknown extension kind: {{kind}}",
@@ -102,7 +102,7 @@ import { Tiktoken as Tiktoken2 } from "js-tiktoken/lite";
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.56.0",
+  version: "0.57.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -1269,8 +1269,49 @@ function runActionProjections(actions, nodes, links, emitter) {
   return { contributions, contributionErrors };
 }
 
+// kernel/orchestrator/confidence-score.ts
+function foldConfidence(base, ops) {
+  let running = base;
+  for (const op of ops) {
+    if (op.kind === "set") running = op.value;
+  }
+  for (const op of ops) {
+    if (op.kind === "delta") running += op.value;
+  }
+  for (const op of ops) {
+    if (op.kind === "floor") running = Math.max(running, op.value);
+  }
+  for (const op of ops) {
+    if (op.kind === "ceil") running = Math.min(running, op.value);
+  }
+  return clamp01(running);
+}
+function clamp01(n) {
+  if (n < 0) return 0;
+  if (n > 1) return 1;
+  return n;
+}
+function applyConfidenceAdjustments(adjustments) {
+  if (adjustments.length === 0) return;
+  const byLink = /* @__PURE__ */ new Map();
+  for (const adj of adjustments) {
+    const bucket = byLink.get(adj.link);
+    if (bucket) bucket.push(adj);
+    else byLink.set(adj.link, [adj]);
+  }
+  for (const [link, adjs] of byLink) {
+    const ops = [...adjs].sort(compareAdjustments).map((a) => a.op);
+    link.confidence = foldConfidence(link.confidence, ops);
+  }
+}
+function compareAdjustments(a, b) {
+  if (a.pluginId !== b.pluginId) return a.pluginId < b.pluginId ? -1 : 1;
+  if (a.extensionId !== b.extensionId) return a.extensionId < b.extensionId ? -1 : 1;
+  return 0;
+}
+
 // kernel/orchestrator/analyzers.ts
-async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, orphanJobFiles, referenceablePaths, cwd, registeredActionIds, emitter, hookDispatcher, reservedNodePaths, brokenLinks, signals, seedIssues = []) {
+async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, referenceablePaths, cwd, registeredActionIds, emitter, hookDispatcher, reservedNodePaths, brokenLinks, nameCollisions, signals, seedIssues = []) {
   const issues = [...seedIssues];
   const contributions = [];
   const contributionErrors = [];
@@ -1281,7 +1322,16 @@ async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sid
     expectedMdPath: o.expectedMdPath
   }));
   const scheduled = orderAnalyzersByPhase(analyzers);
+  const scoreAdjustments = [];
+  const scorableLinks = new Set(internalLinks);
+  let scoresFolded = false;
+  const foldScores = () => {
+    if (scoresFolded) return;
+    scoresFolded = true;
+    applyConfidenceAdjustments(scoreAdjustments);
+  };
   for (const analyzer of scheduled) {
+    if (analyzer.phase !== "score") foldScores();
     const qualifiedId = qualifiedExtensionId(analyzer.pluginId, analyzer.id);
     const declaredContributions = readDeclaredContributionRefs(analyzer);
     const emitContribution = (nodePath, ref, payload) => {
@@ -1344,6 +1394,16 @@ async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sid
         emittedAt: Date.now()
       });
     };
+    const adjustConfidence = analyzer.phase === "score" ? (link, op) => {
+      if (scorableLinks.has(link)) {
+        scoreAdjustments.push({
+          link,
+          pluginId: analyzer.pluginId,
+          extensionId: analyzer.id,
+          op
+        });
+      }
+    } : void 0;
     const emitted = await analyzer.evaluate({
       nodes,
       links: internalLinks,
@@ -1355,7 +1415,6 @@ async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sid
       sidecarRoots,
       annotationContributions,
       viewContributions,
-      orphanJobFiles,
       // `issues` is the live accumulator, mutated by `issues.push(...)`
       // below as each analyzer's emission lands. Late-phase analyzers
       // (`core/issue-counter`) read it to compute cross-analyzer
@@ -1365,7 +1424,9 @@ async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sid
       ...cwd ? { cwd } : {},
       ...reservedNodePaths ? { reservedNodePaths } : {},
       ...brokenLinks ? { brokenLinks } : {},
+      ...nameCollisions && nameCollisions.size > 0 ? { nameCollisions } : {},
       ...signals && signals.length > 0 ? { signals } : {},
+      ...adjustConfidence ? { adjustConfidence } : {},
       emitContribution
     });
     for (const issue of emitted) {
@@ -1376,13 +1437,16 @@ async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sid
     emitter.emit(evt);
     await hookDispatcher.dispatch("analyzer.completed", evt);
   }
-  return { issues, contributions, contributionErrors };
+  foldScores();
+  return { issues, contributions, contributionErrors, linkScores: scoreAdjustments };
 }
 function orderAnalyzersByPhase(analyzers) {
   return analyzers.slice().sort((a, b) => phaseRank(a) - phaseRank(b));
 }
 function phaseRank(a) {
-  return a.phase === "aggregate" ? 1 : 0;
+  if (a.phase === "score") return 0;
+  if (a.phase === "aggregate") return 2;
+  return 1;
 }
 function validateIssue(analyzer, issue, emitter) {
   const severity = issue.severity;
@@ -1405,6 +1469,13 @@ function validateIssue(analyzer, issue, emitter) {
   return { ...issue, analyzerId: issue.analyzerId || analyzer.id };
 }
 
+// kernel/orchestrator/frontmatter-issue-ids.ts
+var FRONTMATTER_ISSUE_ANALYZERS = /* @__PURE__ */ new Set([
+  "frontmatter-invalid",
+  "frontmatter-malformed",
+  "frontmatter-parse-error"
+]);
+
 // kernel/orchestrator/cache.ts
 function indexPriorSnapshot(prior) {
   const priorNodesByPath = /* @__PURE__ */ new Map();
@@ -1433,17 +1504,6 @@ function indexPriorLinks(links, priorNodePaths, byOriginating) {
     else byOriginating.set(key, [link]);
   }
 }
-var FRONTMATTER_ISSUE_ANALYZERS = /* @__PURE__ */ new Set([
-  "frontmatter-invalid",
-  "frontmatter-malformed",
-  // Audit L1: parser parse-error is emitted by
-  // `buildFreshNodeAndValidateFrontmatter` from `raw.parseIssues`. The
-  // raw.parseIssues only flows through the non-cache path; a cached
-  // node skips the rebuild, so the prior issue MUST survive the
-  // incremental scan or the warning silently disappears on a clean
-  // re-scan of an unchanged file.
-  "frontmatter-parse-error"
-]);
 function indexPriorFrontmatterIssues(issues, byNode) {
   for (const issue of issues) {
     if (!FRONTMATTER_ISSUE_ANALYZERS.has(issue.analyzerId)) continue;
@@ -1641,15 +1701,47 @@ function readDirname(node) {
   const base = pathPosix.basename(dir);
   return base.length > 0 ? base : null;
 }
+function collectNameCollisions(nodes, kindRegistry) {
+  const byName = indexNameClaims(nodes, kindRegistry);
+  const collisions = /* @__PURE__ */ new Map();
+  for (const [name, claims] of byName) {
+    const distinct = dedupeClaimsByPath(claims);
+    if (distinct.length >= 2) collisions.set(name, distinct);
+  }
+  return collisions;
+}
+function indexNameClaims(nodes, kindRegistry) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const name = resolvableName(node, kindRegistry);
+    if (name === null) continue;
+    const bucket = byName.get(name) ?? [];
+    bucket.push({ path: node.path, kind: node.kind });
+    byName.set(name, bucket);
+  }
+  return byName;
+}
+function resolvableName(node, kindRegistry) {
+  const descriptor = kindRegistry.get(`${node.provider}/${node.kind}`);
+  if (!descriptor?.identifiers?.includes("frontmatter.name")) return null;
+  const raw = node.frontmatter?.["name"];
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  const normalised = normalizeTrigger(raw);
+  return normalised.length > 0 ? normalised : null;
+}
+function dedupeClaimsByPath(claims) {
+  return [...new Map(claims.map((c) => [c.path, c])).values()].sort(
+    (a, b) => a.path.localeCompare(b.path)
+  );
+}
 
 // kernel/orchestrator/lift-resolved-link-confidence.ts
-var RESERVED_TARGET_CONFIDENCE = 0.1;
-var BROKEN_TARGET_CONFIDENCE = 0.5;
 function liftResolvedLinkConfidence(links, nodes, ctx) {
-  if (!links.some((l) => l.confidence < 1)) return;
+  if (links.length === 0) return;
   const indexes = buildIndexes(nodes, ctx);
   for (const link of links) {
-    if (link.confidence < 1) applyResolution(link, indexes, ctx);
+    link.confidence = 1;
+    applyResolution(link, indexes, ctx);
   }
 }
 function collectBrokenLinks(links, nodes, ctx) {
@@ -1663,15 +1755,8 @@ function collectBrokenLinks(links, nodes, ctx) {
 }
 function applyResolution(link, indexes, ctx) {
   const resolution = resolve5(link, indexes, ctx);
-  if (resolution === "none") {
-    if (isGenuinelyBroken(link, indexes)) {
-      link.confidence = Math.min(link.confidence, BROKEN_TARGET_CONFIDENCE);
-    }
-    return;
-  }
+  if (resolution === "none") return;
   link.resolvedTarget = resolution;
-  if (indexes.nodeByPath.get(resolution)?.virtual) return;
-  link.confidence = ctx.reservedNodePaths.has(resolution) ? RESERVED_TARGET_CONFIDENCE : 1;
 }
 function buildIndexes(nodes, ctx) {
   const byPath2 = /* @__PURE__ */ new Set();
@@ -3143,6 +3228,7 @@ async function runScanInternal(_kernel, options) {
   const postWalkCtx = buildPostWalkTransformCtx(exts.providers, walked.nodes, activeProviderId);
   walked.internalLinks = applyPostWalkTransforms(walked.internalLinks, walked.nodes, postWalkCtx);
   const brokenLinks = collectBrokenLinks(walked.internalLinks, walked.nodes, postWalkCtx);
+  const nameCollisions = collectNameCollisions(walked.nodes, postWalkCtx.kindRegistry);
   recomputeLinkCounts(walked.nodes, walked.internalLinks);
   recomputeExternalRefsCount(walked.nodes, walked.externalLinks, walked.cachedPaths);
   await dispatchExtractorCompleted(exts.extractors, emitter, hookDispatcher);
@@ -3157,7 +3243,6 @@ async function runScanInternal(_kernel, options) {
     walked.sidecarRoots,
     options.annotationContributions ?? [],
     options.viewContributions ?? [],
-    options.orphanJobFiles ?? [],
     options.referenceablePaths,
     options.cwd,
     registeredActionIds,
@@ -3165,6 +3250,7 @@ async function runScanInternal(_kernel, options) {
     hookDispatcher,
     postWalkCtx.reservedNodePaths,
     brokenLinks,
+    nameCollisions,
     walked.signals,
     // Seed the accumulator with orchestrator-emitted frontmatter
     // issues so the aggregate phase (`core/issue-counter`) counts
@@ -3187,7 +3273,7 @@ async function runScanInternal(_kernel, options) {
   const scanCompletedEvent = makeEvent("scan.completed", { stats });
   emitter.emit(scanCompletedEvent);
   await hookDispatcher.dispatch("scan.completed", scanCompletedEvent);
-  return buildScanReturn(walked, issues, renameOps, stats, options, setup);
+  return buildScanReturn(walked, issues, renameOps, stats, options, setup, analyzerResult.linkScores);
 }
 function buildPostWalkTransformCtx(providers, nodes, activeProvider) {
   const { kindRegistry, providerResolution, reservedNamesByProviderKind } = buildProviderIndexes(providers);
@@ -3315,7 +3401,7 @@ function buildScanStats(walked, issues, start) {
     durationMs: Date.now() - start
   };
 }
-function buildScanReturn(walked, issues, renameOps, stats, options, setup) {
+function buildScanReturn(walked, issues, renameOps, stats, options, setup, linkScores) {
   return {
     result: {
       schemaVersion: 1,
@@ -3337,6 +3423,7 @@ function buildScanReturn(walked, issues, renameOps, stats, options, setup) {
     enrichments: walked.enrichments,
     contributions: walked.contributions,
     contributionErrors: walked.contributionErrors,
+    linkScores,
     freshlyRunTuples: walked.freshlyRunTuples
   };
 }
@@ -3766,4 +3853,4 @@ export {
   runScanWithRenames
 };
 //# sourceMappingURL=index.js.map
-//# debugId=bed984e8-cc93-51f3-94cd-c0789fe21577
+//# debugId=12d40092-5030-5aa9-ba9b-939af94ed740

package/dist/migrations/001_initial.sql

@@ -472,6 +472,51 @@ CREATE TABLE scan_contribution_errors (
 CREATE INDEX ix_scan_contribution_errors_plugin_id ON scan_contribution_errors(plugin_id);
 CREATE INDEX ix_scan_contribution_errors_node_path ON scan_contribution_errors(node_path);
 
+-- scan_link_scores: per-op confidence-attribution audit trail. One row
+-- per attributed `ctx.adjustConfidence(link, op)` call buffered by a
+-- `score`-phase analyzer during the scan (the kernel's own built-in
+-- `core/name-reserved` / `core/reference-broken` detectors dogfood the
+-- API, applying penalty deltas on top of the kernel's 1.0 baseline). Lets
+-- an operator answer "why is this link at 0.3?" by listing the plugin /
+-- extension / op that moved it, with the FOLDED final value denormalised
+-- onto every row (`result_confidence` mirrors `scan_links.confidence`).
+--
+-- The link is identified by its structural identity fields
+-- (`source_path`, `target`, `kind`, `normalized_trigger`), the same key
+-- `scan_links` dedups on; `normalized_trigger` is NULL for path-style
+-- links that carry no trigger. `op_kind` is the algebra bucket
+-- (`set` / `delta` / `ceil` / `floor`) and `op_value` its operand.
+--
+-- Belongs to the `scan_*` family. Plain REPLACE-ALL per scan (delete
+-- all, then insert), the same posture as `scan_issues` and
+-- `scan_contribution_errors` — NOT the sweep model `scan_contributions`
+-- uses. A score adjustment is a transient scan finding re-derived in
+-- full on every analyzer pass, so there is no cached-node row to
+-- preserve and no compound PK (multiple ops can land on one link). Index
+-- on `source_path` for the per-node "why this link?" lookup + the rename
+-- heuristic-adjacent reads.
+CREATE TABLE scan_link_scores (
+  plugin_id TEXT NOT NULL,
+  extension_id TEXT NOT NULL,
+  source_path TEXT NOT NULL,
+  target TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  -- NULL for path-style links that carry no trigger (the structural
+  -- identity key mirrors `scan_links`'s dedup tuple).
+  normalized_trigger TEXT,
+  -- Confidence-algebra bucket: `set` / `delta` / `ceil` / `floor`. Kept
+  -- open at the SQL layer (no CHECK) so the op catalog can evolve as a
+  -- kernel + spec change without a DDL migration.
+  op_kind TEXT NOT NULL,
+  op_value REAL NOT NULL,
+  -- Denormalised FOLDED final `link.confidence` after every op for this
+  -- link was applied. Equal across all rows for one link; carried per
+  -- row so the audit read needs no join back to `scan_links`.
+  result_confidence REAL NOT NULL,
+  emitted_at INTEGER NOT NULL
+);
+CREATE INDEX ix_scan_link_scores_source_path ON scan_link_scores(source_path);
+
 -- scan_node_tags: tag system. One row per (node_path, tag) pair.
 -- Projected at persist time from `sidecar.annotations.tags`. Tags are
 -- a skill-map concept (no vendor carries `tags` in frontmatter), so the