@skill-map/cli 0.56.0 → 0.57.0

package/dist/cli.js

@@ -1,6 +1,6 @@
 // cli/entry.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]="49fdc2af-2694-5cd0-ac19-33f8d1dffa9e")}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]="e6038423-ea97-5e66-b371-0916d382d819")}catch(e){}}();
 import { existsSync as existsSync33 } from "fs";
 import { Builtins, Cli as Cli2 } from "clipanion";
 
@@ -250,7 +250,7 @@ function bucketByKind(kind, instance, bag) {
 // 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",
@@ -1815,16 +1815,25 @@ function applyAjvFormats(ajv) {
   addFormats(ajv);
 }
 
+// kernel/util/finding-format.ts
+function formatFinding(parts) {
+  const head = parts.subject ? `\`${parts.subject}\`:
+` : "";
+  const loc = parts.lines && parts.lines.length > 0 ? `L${parts.lines.join(", ")}: ` : "";
+  return `${head}${loc}${parts.body}`;
+}
+
 // plugins/core/analyzers/annotation-field-unknown/text.ts
 var ANNOTATION_FIELD_UNKNOWN_TEXTS = {
-  // Compact finding grammar: the affected node is the finding's own
-  // node, so its path never appears in the message.
+  // Diagnosis bodies (`<what>; <why>`). The shared `formatFinding` helper
+  // owns the subject (the offending key, built before the call); the
+  // affected node is the finding's own node, so its path never appears.
   /** Key inside `annotations:` is not in the curated catalog. */
-  unknownAnnotationKey: "Unknown sidecar key '{{key}}'; not in the annotations catalog.",
+  unknownAnnotationKey: "Unknown sidecar key; not in the annotations catalog",
   /** Top-level key is neither reserved, nor a registered plugin namespace, nor a registered root key. */
-  unknownRootKey: "Unknown sidecar top-level key '{{key}}'; not a reserved block, a plugin namespace, or a root contribution.",
+  unknownRootKey: "Unknown top-level sidecar key; not a reserved block, plugin namespace, or root contribution",
   /** Value under a registered plugin namespace fails the contributed schema. */
-  pluginNamespaceInvalid: "Sidecar block '{{pluginId}}.{{key}}' fails the schema from plugin '{{pluginId}}': {{errors}}.",
+  pluginNamespaceInvalid: "Sidecar block fails the plugin schema; {{errors}}",
   // Tooltips for the per-node view-contribution badges. Singular vs
   // plural keeps the count grammar correct without a sub-template.
   alertTooltipSingle: "This node has 1 unknown field in its sidecar. Open the inspector for details.",
@@ -1877,9 +1886,9 @@ var annotationFieldUnknownAnalyzer = {
               analyzerId: ID9,
               severity: "warn",
               nodeIds: [node.path],
-              message: tx(ANNOTATION_FIELD_UNKNOWN_TEXTS.unknownAnnotationKey, {
-                path: node.path,
-                key
+              message: formatFinding({
+                subject: key,
+                body: tx(ANNOTATION_FIELD_UNKNOWN_TEXTS.unknownAnnotationKey)
               }),
               data: { surface: "annotations", key }
             });
@@ -1904,11 +1913,11 @@ var annotationFieldUnknownAnalyzer = {
               analyzerId: ID9,
               severity: "warn",
               nodeIds: [node.path],
-              message: tx(ANNOTATION_FIELD_UNKNOWN_TEXTS.pluginNamespaceInvalid, {
-                path: node.path,
-                pluginId: key,
-                key: contribKey,
-                errors
+              message: formatFinding({
+                subject: `${key}.${contribKey}`,
+                body: tx(ANNOTATION_FIELD_UNKNOWN_TEXTS.pluginNamespaceInvalid, {
+                  errors
+                })
               }),
               data: { surface: "plugin-namespace", pluginId: key, key: contribKey }
             });
@@ -1920,9 +1929,9 @@ var annotationFieldUnknownAnalyzer = {
           analyzerId: ID9,
           severity: "warn",
           nodeIds: [node.path],
-          message: tx(ANNOTATION_FIELD_UNKNOWN_TEXTS.unknownRootKey, {
-            path: node.path,
-            key
+          message: formatFinding({
+            subject: key,
+            body: tx(ANNOTATION_FIELD_UNKNOWN_TEXTS.unknownRootKey)
           }),
           data: { surface: "root", key }
         });
@@ -1979,12 +1988,15 @@ function collectPluginIds(contributions) {
 // plugins/core/analyzers/annotation-orphan/text.ts
 var ANNOTATION_ORPHAN_TEXTS = {
   /**
-   * Compact finding grammar: line 1 = the orphan sidecar file, line 2
-   * = the diagnosis. The expected markdown path IS the finding's
-   * `nodeIds[0]` (the issue files under the path the sidecar points
-   * at), so it never appears in the message.
+   * Diagnosis body (`<what>; <why>`). The shared `formatFinding` helper
+   * wraps it with the backtick subject (the orphan sidecar file); the
+   * expected markdown path IS the finding's `nodeIds[0]`, so it never
+   * appears in the message. The remediation hint moves to
+   * `Issue.fix.summary` below.
    */
-  message: "{{sidecarPath}}:\nOrphan sidecar; no matching markdown node."
+  message: "Orphan sidecar; no matching markdown node",
+  /** Remediation hint surfaced via `Issue.fix.summary`. */
+  fixSummary: "Run `sm sidecar prune` to remove orphan sidecars."
 };
 
 // plugins/core/analyzers/annotation-orphan/index.ts
@@ -2005,10 +2017,11 @@ var annotationOrphanAnalyzer = {
         analyzerId: ID10,
         severity: "warn",
         nodeIds: [expectedMdRelative],
-        message: tx(ANNOTATION_ORPHAN_TEXTS.message, {
-          sidecarPath: orphan.relativePath,
-          expectedMdPath: orphan.expectedMdPath
+        message: formatFinding({
+          subject: orphan.relativePath,
+          body: tx(ANNOTATION_ORPHAN_TEXTS.message)
         }),
+        fix: { summary: tx(ANNOTATION_ORPHAN_TEXTS.fixSummary) },
         data: {
           sidecarPath: orphan.relativePath,
           expectedMdPath: orphan.expectedMdPath
@@ -2021,14 +2034,17 @@ var annotationOrphanAnalyzer = {
 
 // plugins/core/analyzers/annotation-stale/text.ts
 var ANNOTATION_STALE_TEXTS = {
-  // Compact finding grammar: the affected node is the finding's own
-  // node, so its path never appears in the message.
+  // Diagnosis bodies (`<what>; <why>`). The shared `formatFinding` helper
+  // emits no subject (the affected node IS the finding's own node); the
+  // remediation hint moves to `Issue.fix.summary` below.
   /** body changed since last bump */
-  bodyDrift: "Sidecar `.sm` is stale: body changed since last bump.",
+  bodyDrift: "Sidecar stale; body changed since last bump",
   /** frontmatter changed since last bump */
-  frontmatterDrift: "Sidecar `.sm` is stale: frontmatter changed since last bump.",
+  frontmatterDrift: "Sidecar stale; frontmatter changed since last bump",
   /** both body and frontmatter changed */
-  bothDrift: "Sidecar `.sm` is stale: body and frontmatter changed since last bump.",
+  bothDrift: "Sidecar stale; body and frontmatter changed since last bump",
+  /** Remediation hint surfaced via `Issue.fix.summary`. */
+  fixSummary: "Run `sm bump <path>` to refresh the sidecar.",
   // Tooltips for the `card.footer.right` clock chip emitted alongside
   // the issue. Lists only the drifted face(s), in-sync faces are
   // omitted so the operator immediately sees what's modified without
@@ -2073,7 +2089,8 @@ var annotationStaleAnalyzer = {
         analyzerId: ID11,
         severity: "info",
         nodeIds: [node.path],
-        message: messageFor(status, node.path),
+        message: formatFinding({ body: messageFor(status) }),
+        fix: { summary: tx(ANNOTATION_STALE_TEXTS.fixSummary) },
         data: { status }
       });
       ctx.emitContribution(node.path, staleIcon, {
@@ -2093,14 +2110,14 @@ function staleStatus(overlay) {
   if (status === void 0 || status === null || status === "fresh") return null;
   return status;
 }
-function messageFor(status, path) {
+function messageFor(status) {
   switch (status) {
     case "stale-body":
-      return tx(ANNOTATION_STALE_TEXTS.bodyDrift, { path });
+      return tx(ANNOTATION_STALE_TEXTS.bodyDrift);
     case "stale-frontmatter":
-      return tx(ANNOTATION_STALE_TEXTS.frontmatterDrift, { path });
+      return tx(ANNOTATION_STALE_TEXTS.frontmatterDrift);
     case "stale-both":
-      return tx(ANNOTATION_STALE_TEXTS.bothDrift, { path });
+      return tx(ANNOTATION_STALE_TEXTS.bothDrift);
   }
 }
 function tooltipFor(status) {
@@ -2127,6 +2144,92 @@ var contributionOrphanAnalyzer = {
   }
 };
 
+// plugins/core/analyzers/extractor-collision/text.ts
+var EXTRACTOR_COLLISION_TEXTS = {
+  /**
+   * Per-Signal warn issue: two extractors detected something at
+   * overlapping byte ranges within the same node and the resolver
+   * dropped the loser. Surfaces WHO lost, WHO won, and the tiebreak
+   * reason so the operator can understand why a candidate edge did NOT
+   * become a Link (e.g. a `[link](path)` with `@path` inside the bracket
+   * text: markdown-link wins and the at-directive silently disappears
+   * without this warning).
+   */
+  message: "Overlap collision; {{loserExtractor}} (at {{loserRange}}) lost to {{winnerExtractor}} (at {{winnerRange}}) by {{reason}}, only the winning edge persists",
+  /**
+   * Remediation hint for the range-overlap rejection, surfaced via
+   * `Issue.fix.summary`. Not autofixable: the rule cannot tell which
+   * detection the author meant, so it offers the two resolutions
+   * (rephrase one token, or accept the winner).
+   */
+  rejectedFixSummary: "Rephrase one of the overlapping tokens, or accept the winner."
+};
+
+// plugins/core/analyzers/extractor-collision/index.ts
+var ID13 = "extractor-collision";
+function signalLines(signal) {
+  return signal.range && typeof signal.range.line === "number" ? [signal.range.line] : void 0;
+}
+var extractorCollisionAnalyzer = {
+  id: ID13,
+  pluginId: CORE_PLUGIN_ID,
+  kind: "analyzer",
+  description: "Reports when two extractors detect something at the same span of body text and the resolver drops one.",
+  mode: "deterministic",
+  evaluate(ctx) {
+    const signals = ctx.signals;
+    if (!signals || signals.length === 0) return [];
+    const issues = [];
+    for (const signal of signals) {
+      const issue = makeIssue(signal);
+      if (issue) issues.push(issue);
+    }
+    return issues;
+  }
+};
+function makeIssue(signal) {
+  const resolution = signal.resolution;
+  if (!resolution || resolution.outcome !== "rejected" || !resolution.rejectedBy) return null;
+  const winner = resolution.rejectedBy;
+  const loserCandidate = signal.candidates[resolution.winnerIndex ?? 0];
+  const loserRange = signal.range ? `${signal.range.start}-${signal.range.end}` : "unknown";
+  const winnerRange = `${winner.range.start}-${winner.range.end}`;
+  return {
+    analyzerId: ID13,
+    severity: "warn",
+    nodeIds: [signal.source],
+    message: formatFinding({
+      subject: signal.raw,
+      lines: signalLines(signal),
+      body: tx(EXTRACTOR_COLLISION_TEXTS.message, {
+        loserExtractor: loserCandidate.extractorId,
+        loserRange,
+        winnerExtractor: winner.extractorId,
+        winnerRange,
+        reason: winner.reason
+      })
+    }),
+    fix: { summary: tx(EXTRACTOR_COLLISION_TEXTS.rejectedFixSummary) },
+    data: {
+      loser: {
+        extractorId: loserCandidate.extractorId,
+        raw: signal.raw,
+        range: signal.range ?? null,
+        candidate: {
+          kind: loserCandidate.kind,
+          target: loserCandidate.target,
+          confidence: loserCandidate.confidence
+        }
+      },
+      winner: {
+        extractorId: winner.extractorId,
+        range: winner.range
+      },
+      reason: winner.reason
+    }
+  };
+}
+
 // plugins/core/analyzers/issue-counter/text.ts
 var ISSUE_COUNTER_TEXTS = {
   errorTooltipSingle: "1 error",
@@ -2136,7 +2239,7 @@ var ISSUE_COUNTER_TEXTS = {
 };
 
 // plugins/core/analyzers/issue-counter/index.ts
-var ID13 = "issue-counter";
+var ID14 = "issue-counter";
 var warnCount = {
   slot: "card.footer.right",
   icon: "pi-exclamation-triangle",
@@ -2172,7 +2275,7 @@ function emitTierChips(ctx, ref, severity, counts, singleTooltip, manyTooltip) {
   }
 }
 var issueCounterAnalyzer = {
-  id: ID13,
+  id: ID14,
   pluginId: CORE_PLUGIN_ID,
   kind: "analyzer",
   description: "Emits one aggregate severity chip per node (error + warn counts) from the live issue accumulator.",
@@ -2203,121 +2306,6 @@ var issueCounterAnalyzer = {
   }
 };
 
-// plugins/core/analyzers/job-file-orphan/text.ts
-var JOB_FILE_ORPHAN_TEXTS = {
-  /**
-   * `<path>.md` lives under `.skill-map/jobs/` but no `state_jobs.filePath`
-   * row references it. Compact finding grammar: the file IS the
-   * finding's own node, so its path never appears in the message.
-   */
-  message: "Orphan job file; not referenced by any job. Run `sm job prune --orphan-files` to remove it."
-};
-
-// plugins/core/analyzers/job-file-orphan/index.ts
-var ID14 = "job-file-orphan";
-var jobFileOrphanAnalyzer = {
-  id: ID14,
-  pluginId: CORE_PLUGIN_ID,
-  kind: "analyzer",
-  description: "Flags leftover job result files (no live job references them). Clean up via `sm job prune --orphan-files`.",
-  mode: "deterministic",
-  evaluate(ctx) {
-    const orphans = ctx.orphanJobFiles;
-    if (!orphans || orphans.length === 0) return [];
-    const issues = [];
-    for (const filePath of orphans) {
-      issues.push({
-        analyzerId: ID14,
-        severity: "warn",
-        nodeIds: [filePath],
-        message: tx(JOB_FILE_ORPHAN_TEXTS.message, { filePath }),
-        data: { filePath }
-      });
-    }
-    return issues;
-  }
-};
-
-// plugins/core/analyzers/link-conflict/text.ts
-var LINK_CONFLICT_TEXTS = {
-  /**
-   * Compact finding grammar: line 1 = the disputed target, line 2 =
-   * the short diagnosis. The source is the finding's own node, so it
-   * never appears in the message.
-   */
-  message: "{{target}}:\nDetectors disagree on link kind ({{kindList}})."
-};
-
-// plugins/core/analyzers/link-conflict/index.ts
-var ID15 = "link-conflict";
-var NON_CONFLICTING_KINDS = /* @__PURE__ */ new Set(["points"]);
-var linkConflictAnalyzer = {
-  id: ID15,
-  pluginId: CORE_PLUGIN_ID,
-  kind: "analyzer",
-  description: "Flags conflicting arrow meanings between extractors (e.g. `references` vs `invokes`).",
-  mode: "deterministic",
-  // Bucket links by (source, target), then per-bucket detect distinct
-  // kinds. The branching is intrinsic to the per-bucket conflict
-  // detection.
-  // eslint-disable-next-line complexity
-  evaluate(ctx) {
-    const groups = /* @__PURE__ */ new Map();
-    for (const link of ctx.links) {
-      if (NON_CONFLICTING_KINDS.has(link.kind)) continue;
-      const key = `${link.source}\0${link.target}`;
-      const bucket = groups.get(key);
-      if (bucket) bucket.push(link);
-      else groups.set(key, [link]);
-    }
-    const issues = [];
-    for (const [key, links] of groups) {
-      if (links.length < 2) continue;
-      const kinds = new Set(links.map((l) => l.kind));
-      if (kinds.size < 2) continue;
-      const variantByKind = /* @__PURE__ */ new Map();
-      for (const link of links) {
-        const existing = variantByKind.get(link.kind);
-        if (existing) {
-          for (const src of link.sources) {
-            if (!existing.sources.includes(src)) existing.sources.push(src);
-          }
-          if (rankConfidence(link.confidence) > rankConfidence(existing.confidence)) {
-            existing.confidence = link.confidence;
-          }
-        } else {
-          variantByKind.set(link.kind, {
-            kind: link.kind,
-            sources: [...link.sources],
-            confidence: link.confidence
-          });
-        }
-      }
-      for (const v of variantByKind.values()) v.sources.sort();
-      const variants = [...variantByKind.values()].sort(
-        (a, b) => a.kind.localeCompare(b.kind)
-      );
-      const [source, target] = key.split("\0");
-      const kindList = variants.map((v) => v.kind).join(" / ");
-      issues.push({
-        analyzerId: ID15,
-        severity: "warn",
-        nodeIds: [source, target],
-        message: tx(LINK_CONFLICT_TEXTS.message, {
-          source,
-          target,
-          kindList
-        }),
-        data: { source, target, variants }
-      });
-    }
-    return issues;
-  }
-};
-function rankConfidence(c) {
-  return c;
-}
-
 // kernel/util/link-lines.ts
 function isSelfLoop(link) {
   if (link.source === link.target) return true;
@@ -2336,32 +2324,37 @@ function linkLines(link) {
   }
   return [...lines].sort((a, b) => a - b);
 }
-function linkWhere(link, texts) {
-  const lines = linkLines(link);
-  if (lines.length === 0) return "";
-  return tx(lines.length === 1 ? texts.single : texts.plural, {
-    lines: lines.join(", ")
-  });
-}
+
+// plugins/core/analyzers/link-counter/text.ts
+var LINK_COUNTER_TEXTS = {
+  /** Accessible label for the incoming-links chip. */
+  linksInLabel: "incoming links",
+  /** Accessible label for the outgoing-links chip. */
+  linksOutLabel: "outgoing links",
+  /** Tooltip header for the incoming breakdown (first line). */
+  directionIn: "in",
+  /** Tooltip header for the outgoing breakdown (first line). */
+  directionOut: "out"
+};
 
 // plugins/core/analyzers/link-counter/index.ts
-var ID16 = "link-counter";
+var ID15 = "link-counter";
 var linksIn = {
   slot: "card.footer.left",
   icon: "pi-download",
-  label: "incoming links",
+  label: LINK_COUNTER_TEXTS.linksInLabel,
   emitWhenEmpty: false,
   priority: 10
 };
 var linksOut = {
   slot: "card.footer.left",
   icon: "pi-upload",
-  label: "outgoing links",
+  label: LINK_COUNTER_TEXTS.linksOutLabel,
   emitWhenEmpty: false,
   priority: 20
 };
 var linkCounterAnalyzer = {
-  id: ID16,
+  id: ID15,
   pluginId: CORE_PLUGIN_ID,
   kind: "analyzer",
   description: "Counts incoming and outgoing links per node.",
@@ -2404,24 +2397,115 @@ function emitChip(ctx, nodePath, ref, direction, byKind) {
 }
 function formatBreakdown(byKind, direction) {
   const lines = [...byKind.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([kind, n]) => `${kind}: ${n}`);
-  return [direction, ...lines].join("\n");
+  const dirLabel = direction === "in" ? LINK_COUNTER_TEXTS.directionIn : LINK_COUNTER_TEXTS.directionOut;
+  return [dirLabel, ...lines].join("\n");
+}
+
+// plugins/core/analyzers/link-kind-conflict/text.ts
+var LINK_KIND_CONFLICT_TEXTS = {
+  /**
+   * Diagnosis body (`<what>; <why>`). The shared `formatFinding` helper
+   * wraps it with the backtick subject (the disputed target); the source
+   * is the finding's own node, so it never appears in the message.
+   */
+  message: "Conflicting link kind; detectors disagree ({{kindList}})",
+  /**
+   * Remediation hint surfaced via `Issue.fix.summary`. Not autofixable:
+   * the rule cannot tell which kind the author meant, so it offers the
+   * two valid resolutions (drop one source, or accept the overlap on
+   * purpose). Mirrors the `warn`-severity `link-self-loop` hint shape.
+   */
+  fixSummary: "Remove one of the conflicting sources to settle on a single kind, or ignore the conflict deliberately."
+};
+
+// plugins/core/analyzers/link-kind-conflict/index.ts
+var ID16 = "link-kind-conflict";
+var NON_CONFLICTING_KINDS = /* @__PURE__ */ new Set(["points"]);
+var linkKindConflictAnalyzer = {
+  id: ID16,
+  pluginId: CORE_PLUGIN_ID,
+  kind: "analyzer",
+  description: "Flags conflicting arrow meanings between extractors (e.g. `references` vs `invokes`).",
+  mode: "deterministic",
+  // Bucket links by (source, target), then per-bucket detect distinct
+  // kinds. The branching is intrinsic to the per-bucket conflict
+  // detection.
+  // eslint-disable-next-line complexity
+  evaluate(ctx) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const link of ctx.links) {
+      if (NON_CONFLICTING_KINDS.has(link.kind)) continue;
+      const key = `${link.source}\0${link.target}`;
+      const bucket = groups.get(key);
+      if (bucket) bucket.push(link);
+      else groups.set(key, [link]);
+    }
+    const issues = [];
+    for (const [key, links] of groups) {
+      if (links.length < 2) continue;
+      const kinds = new Set(links.map((l) => l.kind));
+      if (kinds.size < 2) continue;
+      const variantByKind = /* @__PURE__ */ new Map();
+      for (const link of links) {
+        const existing = variantByKind.get(link.kind);
+        if (existing) {
+          for (const src of link.sources) {
+            if (!existing.sources.includes(src)) existing.sources.push(src);
+          }
+          if (rankConfidence(link.confidence) > rankConfidence(existing.confidence)) {
+            existing.confidence = link.confidence;
+          }
+        } else {
+          variantByKind.set(link.kind, {
+            kind: link.kind,
+            sources: [...link.sources],
+            confidence: link.confidence
+          });
+        }
+      }
+      for (const v of variantByKind.values()) v.sources.sort();
+      const variants = [...variantByKind.values()].sort(
+        (a, b) => a.kind.localeCompare(b.kind)
+      );
+      const [source, target] = key.split("\0");
+      const kindList = variants.map((v) => v.kind).join(" / ");
+      issues.push({
+        analyzerId: ID16,
+        severity: "warn",
+        nodeIds: [source, target],
+        message: formatFinding({
+          subject: target,
+          body: tx(LINK_KIND_CONFLICT_TEXTS.message, {
+            kindList
+          })
+        }),
+        fix: { summary: tx(LINK_KIND_CONFLICT_TEXTS.fixSummary) },
+        data: { source, target, variants }
+      });
+    }
+    return issues;
+  }
+};
+function rankConfidence(c) {
+  return c;
 }
 
 // plugins/core/analyzers/link-self-loop/text.ts
 var LINK_SELF_LOOP_TEXTS = {
   /**
-   * Per-edge warn: a node body references itself via the slash /
+   * Per-edge warn body: a node body references itself via the slash /
    * at-directive / markdown-link surface (most commonly because the
    * file's heading IS the invocation token, e.g. `# /deploy` inside
    * `commands/deploy.md`). The link is structurally valid but rarely
    * the operator's intent; UI consumers MAY hide it by default and
    * surface a count.
    */
-  message: "`{{trigger}}`:\nSelf-reference ({{kind}}{{where}}); typically the file's own heading or label. Remove the token or ignore deliberately.",
-  /** Location suffix inside the kind parens, one detection site. */
-  whereSingle: ", line {{lines}}",
-  /** Location suffix inside the kind parens, several detection sites. */
-  wherePlural: ", lines {{lines}}"
+  message: "Self-reference; the skill/command invokes itself, potential loop",
+  /**
+   * Remediation hint surfaced via `Issue.fix.summary` (the Inspector
+   * renders it under the finding, separate from the diagnosis body).
+   */
+  fixSummary: "Remove the token or ignore the self-reference deliberately."
 };
 
 // plugins/core/analyzers/link-self-loop/index.ts
@@ -2433,7 +2517,6 @@ var linkSelfLoopAnalyzer = {
   description: "Flags links whose source is also their own resolved target (e.g. a body heading like `# /deploy` inside the file that defines `/deploy`).",
   mode: "deterministic",
   evaluate(ctx) {
-    if (ctx.links.length === 0) return [];
     const issues = [];
     for (const link of ctx.links) {
       if (!isSelfLoop(link)) continue;
@@ -2441,14 +2524,12 @@ var linkSelfLoopAnalyzer = {
         analyzerId: ID17,
         severity: "warn",
         nodeIds: [link.source],
-        message: tx(LINK_SELF_LOOP_TEXTS.message, {
-          trigger: link.trigger?.originalTrigger ?? link.target,
-          kind: link.kind,
-          where: linkWhere(link, {
-            single: LINK_SELF_LOOP_TEXTS.whereSingle,
-            plural: LINK_SELF_LOOP_TEXTS.wherePlural
-          })
+        message: formatFinding({
+          subject: link.trigger?.originalTrigger ?? link.target,
+          lines: linkLines(link),
+          body: tx(LINK_SELF_LOOP_TEXTS.message)
         }),
+        fix: { summary: tx(LINK_SELF_LOOP_TEXTS.fixSummary) },
         data: {
           target: link.target,
           resolvedTarget: link.resolvedTarget ?? link.target,
@@ -2460,166 +2541,97 @@ var linkSelfLoopAnalyzer = {
   }
 };
 
-// kernel/orchestrator/node-identifiers.ts
-import { posix as pathPosix4 } from "path";
-function deriveNodeIdentifiers(node, kindDescriptor) {
-  const sources = kindDescriptor?.identifiers;
-  if (!sources || sources.length === 0) return [];
-  const out = [];
-  for (const source of sources) {
-    const raw = readIdentifier(source, node);
-    if (!raw) continue;
-    const normalised = normalizeTrigger(raw);
-    if (normalised) out.push(normalised);
-  }
-  return out;
-}
-function readIdentifier(source, node) {
-  if (source === "frontmatter.name") return readFrontmatterName(node);
-  if (source === "filename-basename") return readFilenameBasename(node);
-  return readDirname(node);
-}
-function readFrontmatterName(node) {
-  const raw = node.frontmatter?.["name"];
-  if (typeof raw !== "string") return null;
-  return raw.length > 0 ? raw : null;
-}
-function readFilenameBasename(node) {
-  const base = pathPosix4.basename(node.path);
-  if (!base) return null;
-  const ext = pathPosix4.extname(base);
-  const stem = ext ? base.slice(0, -ext.length) : base;
-  return stem.length > 0 ? stem : null;
-}
-function readDirname(node) {
-  const dir = pathPosix4.dirname(node.path);
-  if (!dir || dir === "." || dir === "/") return null;
-  const base = pathPosix4.basename(dir);
-  return base.length > 0 ? base : null;
-}
+// plugins/core/analyzers/name-collision/text.ts
+var NAME_COLLISION_TEXTS = {
+  /**
+   * Diagnosis body (`<what>; <why>: <evidence>`). The shared
+   * `formatFinding` helper wraps it with the backtick subject (the
+   * normalised name claimed by two or more nodes). The evidence is the
+   * competing node paths.
+   */
+  message: "Name collision; {{count}} nodes declare the same name: {{paths}}"
+};
 
-// 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;
-  const indexes = buildIndexes(nodes, ctx);
-  for (const link of links) {
-    if (link.confidence < 1) applyResolution(link, indexes, ctx);
-  }
-}
-function collectBrokenLinks(links, nodes, ctx) {
-  const broken = /* @__PURE__ */ new Set();
-  if (links.length === 0) return broken;
-  const indexes = buildIndexes(nodes, ctx);
-  for (const link of links) {
-    if (isGenuinelyBroken(link, indexes)) broken.add(link);
-  }
-  return broken;
-}
-function applyResolution(link, indexes, ctx) {
-  const resolution = resolve2(link, indexes, ctx);
-  if (resolution === "none") {
-    if (isGenuinelyBroken(link, indexes)) {
-      link.confidence = Math.min(link.confidence, BROKEN_TARGET_CONFIDENCE);
-    }
-    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 byPath3 = /* @__PURE__ */ new Set();
-  const byName = /* @__PURE__ */ new Map();
-  const nodeByPath = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    byPath3.add(node.path);
-    nodeByPath.set(node.path, node);
-    indexNode(node, ctx, byName);
-  }
-  return { byPath: byPath3, byName, nodeByPath };
-}
-function resolve2(link, indexes, ctx) {
-  if (indexes.byPath.has(link.target)) return link.target;
-  return resolveByName(link, indexes, ctx);
-}
-function isGenuinelyBroken(link, indexes) {
-  if (indexes.byPath.has(link.target)) return false;
-  const stripped = stripTriggerSigil(link.trigger?.normalizedTrigger);
-  if (stripped !== null && indexes.byName.has(stripped)) return false;
-  return true;
-}
-function resolveByName(link, indexes, ctx) {
-  const stripped = stripTriggerSigil(link.trigger?.normalizedTrigger);
-  if (stripped === null) return "none";
-  const candidates = indexes.byName.get(stripped);
-  if (!candidates?.length) return "none";
-  const allowedKinds = lookupAllowedKinds(link, indexes, ctx);
-  if (!allowedKinds?.length) return "none";
-  const winner = candidates.find((c) => allowedKinds.includes(c.kind));
-  return winner ? winner.path : "none";
-}
-function lookupAllowedKinds(link, _indexes, ctx) {
-  if (ctx.activeProvider === null) return void 0;
-  return ctx.providerResolution.get(ctx.activeProvider)?.[link.kind];
-}
-function stripTriggerSigil(normalized) {
-  if (!normalized) return null;
-  const trimmed = normalized.replace(/^[/@]/, "").trim();
-  return trimmed.length === 0 ? null : trimmed;
-}
-function indexNode(node, ctx, byName) {
-  const kindDescriptor = ctx.kindRegistry.get(kindKey(node));
-  const normalised = deriveNodeIdentifiers(node, kindDescriptor);
-  for (const name of normalised) {
-    const entry = { kind: node.kind, path: node.path };
-    const bucket = byName.get(name);
-    if (bucket) {
-      bucket.push(entry);
-    } else {
-      byName.set(name, [entry]);
+// plugins/core/analyzers/name-collision/index.ts
+var ID18 = "name-collision";
+var nameCollisionAnalyzer = {
+  id: ID18,
+  pluginId: CORE_PLUGIN_ID,
+  kind: "analyzer",
+  mode: "deterministic",
+  description: "Flags two or more nodes that declare the same resolvable `name`.",
+  // Pure projector of `ctx.nameCollisions` (computed once by the
+  // orchestrator from the kind registry). One `error` per colliding name.
+  evaluate(ctx) {
+    const collisions = ctx.nameCollisions;
+    if (!collisions || collisions.size === 0) return [];
+    const issues = [];
+    for (const [name, claims] of collisions) {
+      const paths = claims.map((c) => c.path);
+      issues.push({
+        analyzerId: ID18,
+        severity: "error",
+        nodeIds: paths,
+        message: formatFinding({
+          subject: name,
+          body: tx(NAME_COLLISION_TEXTS.message, {
+            count: paths.length,
+            paths: paths.join(", ")
+          })
+        }),
+        data: {
+          name,
+          claims: claims.map((c) => ({ path: c.path, kind: c.kind }))
+        }
+      });
     }
+    return issues;
   }
-}
-function kindKey(node) {
-  return `${node.provider}/${node.kind}`;
-}
+};
+
+// kernel/orchestrator/confidence-constants.ts
+var RESERVED_PENALTY = 0.9;
+var BROKEN_PENALTY = 0.5;
 
 // plugins/core/analyzers/name-reserved/text.ts
 var NAME_RESERVED_TEXTS = {
   /**
-   * Target-side message: emitted on the user file that collides with
-   * a runtime built-in. Same wording skill-map shipped before the
-   * source-side link finding landed.
+   * Target-side body (`<what>; <why>`): emitted on the user file that
+   * collides with a runtime built-in. The shared `formatFinding` helper
+   * adds no subject (the offending node IS the finding's own node); the
+   * remediation hint moves to `Issue.fix.summary` below.
    */
-  message: "Name collision: this {{kind}} name is already used by the {{provider}} runtime built-in, which shadows this file. Rename the file or its `frontmatter.name`.",
+  message: "Reserved name; this {{kind}} name is shadowed by the {{provider}} runtime built-in",
+  /** Remediation hint for the target-side finding. */
+  fixSummary: "Rename the file or its frontmatter.name.",
   /**
-   * Source-side message: emitted on the node that AUTHORED a link
-   * whose target resolves to a reserved name. Explains WHY the link's
-   * confidence dropped to `RESERVED_TARGET_CONFIDENCE` (today `0.1`):
-   * the kernel saw the target match a runtime built-in and downgraded
-   * the edge so the operator notices.
+   * Source-side body (`<what>; <why>`): emitted on the node that
+   * AUTHORED a link whose target resolves to a reserved name. Reports the
+   * fact (the runtime built-in shadows this edge); it deliberately does
+   * NOT assert a confidence number, since the value is owned by the
+   * `score`-phase scorers and may vary or be absent. The shared
+   * `formatFinding` helper wraps it with the backtick target subject and
+   * the `L<line>:` location prefix.
    */
-  linkMessage: "{{target}}:\nName collision: resolves to a {{provider}} built-in ({{reservedKind}} `{{reservedPath}}`){{where}}; the built-in wins, so this edge drops to confidence {{confidence}}. Rename the target file or its `frontmatter.name`.",
-  /** Location suffix after the built-in parens, one detection site. */
-  whereSingle: " (line {{lines}})",
-  /** Location suffix after the built-in parens, several detection sites. */
-  wherePlural: " (lines {{lines}})"
+  linkMessage: "Reserved name; resolves to the {{provider}} built-in ({{reservedKind}} `{{reservedPath}}`), the built-in shadows this edge",
+  /** Remediation hint for the source-side finding. */
+  linkFixSummary: "Rename the target file or its frontmatter.name."
 };
 
 // plugins/core/analyzers/name-reserved/index.ts
-var ID18 = "name-reserved";
+var ID19 = "name-reserved";
 var nameReservedAnalyzer = {
-  id: ID18,
+  id: ID19,
   pluginId: CORE_PLUGIN_ID,
   kind: "analyzer",
   description: "Flags two kinds of reserved-name collision: a file whose name shadows a built-in command of the active runtime, and a link that resolves to one of those reserved names.",
   mode: "deterministic",
+  phase: "score",
   // eslint-disable-next-line complexity
   evaluate(ctx) {
     const reserved = ctx.reservedNodePaths;
     if (!reserved || reserved.size === 0) return [];
+    const adjust = ctx.adjustConfidence;
     const byPath3 = /* @__PURE__ */ new Map();
     for (const node of ctx.nodes) byPath3.set(node.path, node);
     const issues = [];
@@ -2627,35 +2639,41 @@ var nameReservedAnalyzer = {
       const node = byPath3.get(path);
       if (!node) continue;
       issues.push({
-        analyzerId: ID18,
+        analyzerId: ID19,
         severity: "warn",
         nodeIds: [node.path],
-        message: tx(NAME_RESERVED_TEXTS.message, {
-          path: node.path,
-          provider: node.provider,
-          kind: node.kind
+        message: formatFinding({
+          body: tx(NAME_RESERVED_TEXTS.message, {
+            provider: node.provider,
+            kind: node.kind
+          })
         }),
+        fix: { summary: tx(NAME_RESERVED_TEXTS.fixSummary) },
         data: { provider: node.provider, kind: node.kind, surface: "target" }
       });
     }
     for (const link of ctx.links) {
-      if (link.confidence !== RESERVED_TARGET_CONFIDENCE) continue;
       const reservedPath = link.resolvedTarget;
       if (!reservedPath || !reserved.has(reservedPath)) continue;
       const reservedNode = byPath3.get(reservedPath);
       if (!reservedNode) continue;
+      if (adjust) {
+        adjust(link, { kind: "delta", value: -RESERVED_PENALTY });
+      }
       issues.push({
-        analyzerId: ID18,
+        analyzerId: ID19,
         severity: "warn",
         nodeIds: [link.source],
-        message: tx(NAME_RESERVED_TEXTS.linkMessage, {
-          target: link.target,
-          provider: reservedNode.provider,
-          reservedKind: reservedNode.kind,
-          reservedPath: reservedNode.path,
-          confidence: RESERVED_TARGET_CONFIDENCE.toFixed(2),
-          where: linkWhereSuffix(link)
+        message: formatFinding({
+          subject: link.target,
+          lines: linkLines(link),
+          body: tx(NAME_RESERVED_TEXTS.linkMessage, {
+            provider: reservedNode.provider,
+            reservedKind: reservedNode.kind,
+            reservedPath: reservedNode.path
+          })
         }),
+        fix: { summary: tx(NAME_RESERVED_TEXTS.linkFixSummary) },
         data: {
           target: link.target,
           kind: link.kind,
@@ -2669,15 +2687,13 @@ var nameReservedAnalyzer = {
     return issues;
   }
 };
-function linkWhereSuffix(link) {
-  return linkWhere(link, {
-    single: NAME_RESERVED_TEXTS.whereSingle,
-    plural: NAME_RESERVED_TEXTS.wherePlural
-  });
-}
 
 // plugins/core/analyzers/node-stability/text.ts
 var NODE_STABILITY_TEXTS = {
+  /** Issue body (`<what>; <why>`) for an experimental-marked node. */
+  experimental: "Marked experimental; API may change",
+  /** Issue body (`<what>; <why>`) for a deprecated-marked node. */
+  deprecated: "Marked deprecated; avoid in new code",
   /** Label of the inspector action button that sets the lifecycle stage. */
   setLabel: "Set stability",
   /** Prompt label for the enum-pick stability input. */
@@ -2691,7 +2707,7 @@ var NODE_STABILITY_TEXTS = {
 };
 
 // plugins/core/analyzers/node-stability/index.ts
-var ID19 = "node-stability";
+var ID20 = "node-stability";
 var EXPERIMENTAL_TOOLTIP = "Experimental: API may change";
 var DEPRECATED_TOOLTIP = "Deprecated: avoid in new code";
 var experimental = {
@@ -2713,7 +2729,7 @@ var setStabilityButton = {
   priority: 15
 };
 var nodeStabilityAnalyzer = {
-  id: ID19,
+  id: ID20,
   pluginId: CORE_PLUGIN_ID,
   kind: "analyzer",
   description: "Reports a node's stability stage (`experimental`, `deprecated`) on the card.",
@@ -2732,10 +2748,10 @@ var nodeStabilityAnalyzer = {
           tooltip: EXPERIMENTAL_TOOLTIP
         });
         issues.push({
-          analyzerId: ID19,
+          analyzerId: ID20,
           severity: "info",
           nodeIds: [node.path],
-          message: `Node '${node.path}' is marked experimental: API may change.`,
+          message: formatFinding({ body: tx(NODE_STABILITY_TEXTS.experimental) }),
           data: { stability }
         });
       } else if (stability === "deprecated") {
@@ -2745,10 +2761,10 @@ var nodeStabilityAnalyzer = {
           severity: "warn"
         });
         issues.push({
-          analyzerId: ID19,
+          analyzerId: ID20,
           severity: "warn",
           nodeIds: [node.path],
-          message: `Node '${node.path}' is marked deprecated: avoid in new code.`,
+          message: formatFinding({ body: tx(NODE_STABILITY_TEXTS.deprecated) }),
           data: { stability }
         });
       }
@@ -2794,17 +2810,17 @@ function emitSetStabilityButton(ctx, nodePath, current) {
 // plugins/core/analyzers/node-superseded/text.ts
 var NODE_SUPERSEDED_TEXTS = {
   /**
-   * Compact finding grammar: line 1 = the superseding artifact, line
-   * 2 = what it means. The superseded node is the finding's own node,
-   * so its path never appears in the message.
+   * Diagnosis body (`<what>; <why>`). The shared `formatFinding` helper
+   * wraps it with the backtick subject (the superseding artifact); the
+   * superseded node is the finding's own node, so its path never appears.
    */
-  message: "{{supersededBy}}:\nSupersedes this node."
+  message: "Superseded; a newer node supersedes this one"
 };
 
 // plugins/core/analyzers/node-superseded/index.ts
-var ID20 = "node-superseded";
+var ID21 = "node-superseded";
 var nodeSupersededAnalyzer = {
-  id: ID20,
+  id: ID21,
   pluginId: CORE_PLUGIN_ID,
   kind: "analyzer",
   description: "Marks nodes replaced by a newer one via `supersededBy`.",
@@ -2821,12 +2837,12 @@ var nodeSupersededAnalyzer = {
       const supersededBy = pickSupersededBy(node);
       if (supersededBy === null) continue;
       issues.push({
-        analyzerId: ID20,
+        analyzerId: ID21,
         severity: "info",
         nodeIds: [node.path],
-        message: tx(NODE_SUPERSEDED_TEXTS.message, {
-          path: node.path,
-          supersededBy
+        message: formatFinding({
+          subject: supersededBy,
+          body: tx(NODE_SUPERSEDED_TEXTS.message)
         }),
         data: { supersededBy }
       });
@@ -2845,22 +2861,27 @@ function pickSupersededBy(node) {
 }
 
 // plugins/core/analyzers/reference-broken/index.ts
-import { resolve as resolve3 } from "path";
+import { resolve as resolve2 } from "path";
 
 // plugins/core/analyzers/reference-broken/text.ts
 var REFERENCE_BROKEN_TEXTS = {
   /**
-   * Compact finding grammar: line 1 = the unresolved target, line 2 =
-   * the short diagnosis plus WHERE the reference sits (`{{where}}` is
-   * the pre-rendered location suffix below, or empty when the link
-   * carries no line info). The source is the finding's own node, so it
-   * never appears in the message.
+   * Diagnosis body (`<what>; <why>`). The shared `formatFinding` helper
+   * wraps it with the backtick subject (the unresolved target) and the
+   * `L<line>:` location prefix; the source is the finding's own node, so
+   * it never appears in the message.
+   */
+  message: "Broken {{kindLabel}}; target not found in the graph or on disk",
+  /**
+   * Remediation hint surfaced via `Issue.fix.summary`. Not autofixable:
+   * the rule cannot tell which resolution the author wants. The folder
+   * option maps to `scan.referencePaths` ("Folders for link validation"
+   * in Settings), the rule's own escape hatch: it clears only PATH-style
+   * breaks (the file exists on disk outside the indexed graph). A
+   * trigger-style `/cmd` / `@agent` break is settled by the path/name or
+   * removal options instead.
    */
-  message: "{{target}}:\nBroken {{kindLabel}}{{where}}.",
-  /** Location suffix, one detection site. */
-  whereSingle: " (line {{lines}})",
-  /** Location suffix, several detection sites. */
-  wherePlural: " (lines {{lines}})",
+  fixSummary: "Fix the path or name, remove the broken link, or add its folder under Folders for link validation.",
   /**
    * Human noun per link kind for the message above. Fallback for an
    * off-catalog kind: `<kind> link` (composed in the analyzer).
@@ -2880,13 +2901,14 @@ var REFERENCE_BROKEN_TEXTS = {
 };
 
 // plugins/core/analyzers/reference-broken/index.ts
-var ID21 = "reference-broken";
+var ID22 = "reference-broken";
 var referenceBrokenAnalyzer = {
-  id: ID21,
+  id: ID22,
   pluginId: CORE_PLUGIN_ID,
   kind: "analyzer",
   description: "Flags arrows pointing at a node not part of the current scan.",
   mode: "deterministic",
+  phase: "score",
   // No `ui` declaration: this analyzer used to emit a per-finding
   // counter chip on `card.footer.right`, but that chip duplicated the
   // aggregate severity counters now owned by `core/issue-counter`. The
@@ -2902,10 +2924,12 @@ var referenceBrokenAnalyzer = {
     const broken = ctx.brokenLinks;
     if (!broken || broken.size === 0) return [];
     const refIndex = buildReferenceIndex(ctx);
+    const adjust = ctx.adjustConfidence;
     const issues = [];
     for (const link of ctx.links) {
       if (!broken.has(link)) continue;
       if (refIndex && resolvesViaReferencePaths(link, refIndex)) continue;
+      penalizeBrokenConfidence(adjust, link);
       issues.push(buildIssue(link));
     }
     return issues;
@@ -2915,9 +2939,14 @@ function buildReferenceIndex(ctx) {
   if (!ctx.referenceablePaths || ctx.referenceablePaths.size === 0 || !ctx.cwd) return null;
   return { paths: ctx.referenceablePaths, cwd: ctx.cwd };
 }
+function penalizeBrokenConfidence(adjust, link) {
+  if (adjust) {
+    adjust(link, { kind: "delta", value: -BROKEN_PENALTY });
+  }
+}
 function buildIssue(link) {
   return {
-    analyzerId: ID21,
+    analyzerId: ID22,
     // `error`, not `warn`: a link whose target is not in the scan is a
     // structural defect the operator must notice, and the card chip
     // paints `danger` (red) to match. Per the chip-vs-issue policy in
@@ -2926,14 +2955,14 @@ function buildIssue(link) {
     // and the global error count on the card.
     severity: "error",
     nodeIds: [link.source],
-    message: tx(REFERENCE_BROKEN_TEXTS.message, {
-      target: link.target,
-      kindLabel: REFERENCE_BROKEN_TEXTS.kindLabels[link.kind] ?? tx(REFERENCE_BROKEN_TEXTS.kindLabelFallback, { kind: link.kind }),
-      where: linkWhere(link, {
-        single: REFERENCE_BROKEN_TEXTS.whereSingle,
-        plural: REFERENCE_BROKEN_TEXTS.wherePlural
+    message: formatFinding({
+      subject: link.target,
+      lines: linkLines(link),
+      body: tx(REFERENCE_BROKEN_TEXTS.message, {
+        kindLabel: REFERENCE_BROKEN_TEXTS.kindLabels[link.kind] ?? tx(REFERENCE_BROKEN_TEXTS.kindLabelFallback, { kind: link.kind })
       })
     }),
+    fix: { summary: tx(REFERENCE_BROKEN_TEXTS.fixSummary) },
     data: {
       target: link.target,
       kind: link.kind,
@@ -2943,7 +2972,7 @@ function buildIssue(link) {
 }
 function resolvesViaReferencePaths(link, refIndex) {
   if (!isPathStyleLink(link)) return false;
-  return refIndex.paths.has(resolve3(refIndex.cwd, link.target));
+  return refIndex.paths.has(resolve2(refIndex.cwd, link.target));
 }
 function isPathStyleLink(link) {
   const sigil = link.trigger?.normalizedTrigger?.charAt(0);
@@ -2954,29 +2983,36 @@ function isPathStyleLink(link) {
 // plugins/core/analyzers/reference-redundant/text.ts
 var REFERENCE_REDUNDANT_TEXTS = {
   /**
-   * Compact finding grammar (subject first, `\n` renders as a line
-   * break in the inspector and flattens to a space in `sm check`):
-   *
-   *   <resolvedTarget>:
-   *   Duplicate reference (2): `references/x.md` (124, 145).
-   *
+   * Diagnosis body (`<what>; <why>`). Kind-agnostic wording ("links", not
+   * "reference"): the redundancy can span different link kinds (e.g.
+   * `invokes` + `references` to one node), so the message never names a
+   * single kind. The shared `formatFinding` helper wraps it with the
+   * backtick subject (the resolved target); no `L<line>:` prefix because
+   * the per-occurrence line numbers stay inline in the rendered
+   * occurrence list. Remediation lives in `fix.summary`, not the message.
    * Occurrences are grouped BY TRIGGER: each distinct trigger text
-   * appears once with its line numbers collapsed into one paren list.
-   * The source node is the finding's own node, so it never appears.
+   * appears once with its line numbers collapsed into one paren list. The
+   * source node is the finding's own node, so it never appears.
    */
-  message: "{{resolvedTarget}}:\nDuplicate reference ({{count}}): {{occurrences}}.",
+  message: "Redundant links; the target is reached {{count}} times: {{occurrences}}",
+  /**
+   * Remediation hint surfaced via `Issue.fix.summary`. Phrased as
+   * optional: severity is `info` and keeping multiple forms can be
+   * deliberate, so the hint offers consolidation OR keeping the overlap.
+   */
+  fixSummary: "Consolidate the links into one, or keep the overlap deliberately.",
   /** Inline separator between trigger groups in the message. */
   occurrenceSeparator: ", ",
   /** Per-trigger formatting: the trigger once, its lines grouped. */
-  occurrence: "`{{trigger}}` ({{lines}})",
+  occurrence: "`{{trigger}}` (L{{lines}})",
   /** Placeholder for an occurrence whose extractor recorded no line. */
   lineUnknown: "?"
 };
 
 // plugins/core/analyzers/reference-redundant/index.ts
-var ID22 = "reference-redundant";
+var ID23 = "reference-redundant";
 var referenceRedundantAnalyzer = {
-  id: ID22,
+  id: ID23,
   pluginId: CORE_PLUGIN_ID,
   kind: "analyzer",
   description: "Flags when one node references the same target through two or more different links (e.g. a markdown link plus a `references:` entry).",
@@ -2999,14 +3035,17 @@ var referenceRedundantAnalyzer = {
       const [source, resolvedTarget] = key.split("\0");
       const flat = flattenOccurrences(links);
       issues.push({
-        analyzerId: ID22,
+        analyzerId: ID23,
         severity: "info",
         nodeIds: [source],
-        message: tx(REFERENCE_REDUNDANT_TEXTS.message, {
-          resolvedTarget,
-          count: flat.length,
-          occurrences: formatGroupedOccurrences(flat)
+        message: formatFinding({
+          subject: resolvedTarget,
+          body: tx(REFERENCE_REDUNDANT_TEXTS.message, {
+            count: flat.length,
+            occurrences: formatGroupedOccurrences(flat)
+          })
         }),
+        fix: { summary: tx(REFERENCE_REDUNDANT_TEXTS.fixSummary) },
         data: {
           target: resolvedTarget,
           resolvedTarget,
@@ -3069,7 +3108,7 @@ function formatGroupedOccurrences(occurrences) {
 
 // kernel/adapters/schema-validators.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, resolve as resolve4 } from "path";
+import { dirname as dirname2, resolve as resolve3 } from "path";
 import { createRequire as createRequire2 } from "module";
 import { Ajv2020 as Ajv20202 } from "ajv/dist/2020.js";
 
@@ -3137,14 +3176,14 @@ function buildSchemaValidators() {
   });
   applyAjvFormats(ajv);
   for (const rel of SUPPORTING_SCHEMAS) {
-    const file = resolve4(specRoot, rel);
+    const file = resolve3(specRoot, rel);
     if (!existsSyncSafe(file)) continue;
     const schema = JSON.parse(readFileSync2(file, "utf8"));
     ajv.addSchema(schema);
   }
   const validators = /* @__PURE__ */ new Map();
   for (const [name, rel] of Object.entries(SCHEMA_FILES)) {
-    const file = resolve4(specRoot, rel);
+    const file = resolve3(specRoot, rel);
     const schema = JSON.parse(readFileSync2(file, "utf8"));
     const byId = typeof schema.$id === "string" ? ajv.getSchema(schema.$id) : void 0;
     validators.set(name, byId ?? ajv.compile(schema));
@@ -3216,7 +3255,7 @@ function buildProviderFrontmatterValidator(providers) {
     allowUnionTypes: true
   });
   applyAjvFormats(ajv);
-  const baseFile = resolve4(specRoot, "schemas/frontmatter/base.schema.json");
+  const baseFile = resolve3(specRoot, "schemas/frontmatter/base.schema.json");
   const baseSchema = JSON.parse(readFileSync2(baseFile, "utf8"));
   ajv.addSchema(baseSchema);
   registerProviderAuxiliarySchemas(ajv, providers);
@@ -3315,16 +3354,25 @@ function existsSyncSafe(path) {
   }
 }
 
+// kernel/orchestrator/frontmatter-issue-ids.ts
+var FRONTMATTER_ISSUE_ANALYZERS = /* @__PURE__ */ new Set([
+  "frontmatter-invalid",
+  "frontmatter-malformed",
+  "frontmatter-parse-error"
+]);
+
 // plugins/core/analyzers/schema-violation/text.ts
 var SCHEMA_VIOLATION_TEXTS = {
-  // Compact finding grammar: the affected node (or the link's source)
-  // is the finding's own node, so its path never appears.
-  /** `Schema validation failed: <errors>` */
-  nodeFailure: "Schema validation failed: {{errors}}",
-  /** `<target>:\nLink failed schema validation: <errors>` */
-  linkFailure: "{{target}}:\nLink failed schema validation: {{errors}}",
-  /** `Missing required frontmatter: <missing>.` */
-  frontmatterBaseFailure: "Missing required frontmatter: {{missing}}.",
+  // Diagnosis bodies (`<what>; <why>`). The shared `formatFinding` helper
+  // owns the subject / location chrome: the node + frontmatter findings
+  // carry no subject (the affected node IS the finding's own node), the
+  // link finding uses the link target as its subject.
+  /** `Schema validation failed; <errors>` */
+  nodeFailure: "Schema validation failed; {{errors}}",
+  /** `<target>` subject + `Link failed schema validation; <errors>` */
+  linkFailure: "Link failed schema validation; {{errors}}",
+  /** `Missing required frontmatter; <missing>` */
+  frontmatterBaseFailure: "Missing required frontmatter; {{missing}}",
   /** Singular tooltip on the alert / chip when a node has exactly one validation failure. */
   alertTooltipSingle: "Frontmatter or schema validation failed.",
   /** Plural tooltip; `{{count}}` capped at 99 in the chip badge but the tooltip text shows the raw count. */
@@ -3332,9 +3380,9 @@ var SCHEMA_VIOLATION_TEXTS = {
 };
 
 // plugins/core/analyzers/schema-violation/index.ts
-var ID23 = "schema-violation";
+var ID24 = "schema-violation";
 var schemaViolationAnalyzer = {
-  id: ID23,
+  id: ID24,
   pluginId: CORE_PLUGIN_ID,
   kind: "analyzer",
   description: "Flags nodes or links that violate the project schemas.",
@@ -3355,10 +3403,11 @@ var schemaViolationAnalyzer = {
     const validators = loadSchemaValidators();
     const findings = [];
     const perNode = /* @__PURE__ */ new Map();
+    const kernelFlaggedNodes = collectKernelFlaggedNodes(ctx.accumulatedIssues);
     for (const node of ctx.nodes) {
       const before = findings.length;
       collectNodeFindings(validators, node, findings);
-      collectFrontmatterBaseFindings(node, findings);
+      collectFrontmatterBaseFindings(node, findings, kernelFlaggedNodes);
       if (findings.length > before) {
         let worst = "warn";
         for (let i = before; i < findings.length; i++) {
@@ -3385,17 +3434,27 @@ function collectNodeFindings(v, node, out) {
   const result = v.validate("node", toNodeForSchema(node));
   if (result.ok) return;
   out.push({
-    analyzerId: ID23,
+    analyzerId: ID24,
     severity: "error",
     nodeIds: [node.path],
-    message: tx(SCHEMA_VIOLATION_TEXTS.nodeFailure, {
-      path: node.path,
-      errors: result.errors
+    message: formatFinding({
+      body: tx(SCHEMA_VIOLATION_TEXTS.nodeFailure, {
+        errors: result.errors
+      })
     }),
     data: { target: "node", path: node.path }
   });
 }
-function collectFrontmatterBaseFindings(node, out) {
+function collectKernelFlaggedNodes(accumulated) {
+  const flagged = /* @__PURE__ */ new Set();
+  for (const issue of accumulated ?? []) {
+    if (!FRONTMATTER_ISSUE_ANALYZERS.has(issue.analyzerId)) continue;
+    for (const id of issue.nodeIds) flagged.add(id);
+  }
+  return flagged;
+}
+function collectFrontmatterBaseFindings(node, out, kernelFlagged) {
+  if (kernelFlagged.has(node.path)) return;
   if (node.provider === "markdown") return;
   if (node.bytes.frontmatter === 0) return;
   const fm = node.frontmatter ?? {};
@@ -3404,16 +3463,17 @@ function collectFrontmatterBaseFindings(node, out) {
   if (isMissingStringField(fm, "description")) missing.push("description");
   if (missing.length === 0) return;
   out.push({
-    analyzerId: ID23,
+    analyzerId: ID24,
     // `warn` (not `error`) so the default `sm scan` exit code stays
     // 0 even when nodes are missing frontmatter base fields. Strict
     // mode (`sm scan --strict`) still escalates to exit 1. Matches
     // the `frontmatter-invalid` severity policy of the orchestrator.
     severity: "warn",
     nodeIds: [node.path],
-    message: tx(SCHEMA_VIOLATION_TEXTS.frontmatterBaseFailure, {
-      path: node.path,
-      missing: missing.join(", ")
+    message: formatFinding({
+      body: tx(SCHEMA_VIOLATION_TEXTS.frontmatterBaseFailure, {
+        missing: missing.join(", ")
+      })
     }),
     data: { target: "frontmatter", path: node.path, missing }
   });
@@ -3426,13 +3486,14 @@ function collectLinkFindings(v, link, out) {
   const result = v.validate("link", toLinkForSchema(link));
   if (result.ok) return;
   out.push({
-    analyzerId: ID23,
+    analyzerId: ID24,
     severity: "error",
     nodeIds: [link.source],
-    message: tx(SCHEMA_VIOLATION_TEXTS.linkFailure, {
-      source: link.source,
-      target: link.target,
-      errors: result.errors
+    message: formatFinding({
+      subject: link.target,
+      body: tx(SCHEMA_VIOLATION_TEXTS.linkFailure, {
+        errors: result.errors
+      })
     }),
     data: { target: "link", source: link.source, to: link.target }
   });
@@ -3453,292 +3514,16 @@ function toNodeForSchema(node) {
     sidecar: node.sidecar ?? void 0
   };
 }
-function toLinkForSchema(link) {
-  return {
-    source: link.source,
-    target: link.target,
-    kind: link.kind,
-    confidence: link.confidence,
-    sources: link.sources,
-    trigger: link.trigger ?? void 0,
-    location: link.location ?? void 0,
-    raw: link.raw ?? void 0
-  };
-}
-
-// plugins/core/analyzers/signal-collision/text.ts
-var SIGNAL_COLLISION_TEXTS = {
-  /**
-   * Per-Signal warn issue: two extractors detected something at
-   * overlapping byte ranges within the same node and the resolver
-   * dropped the loser. Surfaces WHO lost, WHO won, and the tiebreak
-   * reason so the operator can understand why a candidate edge did NOT
-   * become a Link.
-   *
-   * Placeholders are deliberately verbose because this is one of the
-   * few diagnostic surfaces where the operator may need to disambiguate
-   * a confusing graph (e.g. a `[link](path)` followed by `@path` inside
-   * the same paragraph, the markdown-link wins and the at-directive
-   * silently disappears without this warning).
-   */
-  message: "`{{loserRaw}}`:\nOverlap collision: {{loserExtractor}} (at {{loserRange}}) lost to {{winnerExtractor}} (at {{winnerRange}}) by {{reason}}; only the winning edge persists.",
-  /**
-   * Same warn but for the rare case the resolver rejected a Signal
-   * because the operator disabled its extractor via
-   * `plugins.<id>.extensions.<extId>.enabled`. Phase 4+ stub: today the
-   * filter is not wired so this template is unreachable from the
-   * resolver; documented now so the analyzer stays forward-compatible
-   * with the upcoming filter pass.
-   */
-  messageExtractorDisabled: "`{{loserRaw}}`:\nDropped: extension `{{extractorId}}` is disabled. Re-enable it in Settings or via `sm plugins enable`.",
-  /**
-   * Same warn but for the future confidence floor case. Phase 4+ stub:
-   * today the resolver materialises every winning candidate regardless
-   * of confidence, so this template is unreachable; documented for
-   * forward compatibility.
-   */
-  messageBelowFloor: "`{{loserRaw}}`:\nDropped: confidence {{confidence}} is below the threshold {{threshold}}."
-};
-
-// plugins/core/analyzers/signal-collision/index.ts
-var ID24 = "signal-collision";
-var signalCollisionAnalyzer = {
-  id: ID24,
-  pluginId: CORE_PLUGIN_ID,
-  kind: "analyzer",
-  description: "Reports when two extractors fight over the same span of body text, or when a candidate link is dropped (extractor disabled, confidence too low) before it reaches the graph.",
-  mode: "deterministic",
-  evaluate(ctx) {
-    const signals = ctx.signals;
-    if (!signals || signals.length === 0) return [];
-    const issues = [];
-    for (const signal of signals) {
-      const issue = makeIssue(signal);
-      if (issue) issues.push(issue);
-    }
-    return issues;
-  }
-};
-function makeIssue(signal) {
-  const resolution = signal.resolution;
-  if (!resolution || resolution.outcome !== "rejected") return null;
-  if (resolution.rejectedBy) {
-    const winner = resolution.rejectedBy;
-    const winnerCandidate = signal.candidates[resolution.winnerIndex ?? 0];
-    const loserRange = signal.range ? `${signal.range.start}-${signal.range.end}` : "unknown";
-    const winnerRange = `${winner.range.start}-${winner.range.end}`;
-    return {
-      analyzerId: ID24,
-      severity: "warn",
-      nodeIds: [signal.source],
-      message: tx(SIGNAL_COLLISION_TEXTS.message, {
-        loserExtractor: winnerCandidate.extractorId,
-        loserRaw: signal.raw,
-        loserRange,
-        winnerExtractor: winner.extractorId,
-        winnerRange,
-        reason: winner.reason
-      }),
-      data: {
-        loser: {
-          extractorId: winnerCandidate.extractorId,
-          raw: signal.raw,
-          range: signal.range ?? null,
-          candidate: {
-            kind: winnerCandidate.kind,
-            target: winnerCandidate.target,
-            confidence: winnerCandidate.confidence
-          }
-        },
-        winner: {
-          extractorId: winner.extractorId,
-          range: winner.range
-        },
-        reason: winner.reason
-      }
-    };
-  }
-  if (resolution.extractorDisabled) {
-    const loserRange = signal.range ? `${signal.range.start}-${signal.range.end}` : "unknown";
-    return {
-      analyzerId: ID24,
-      severity: "warn",
-      nodeIds: [signal.source],
-      message: tx(SIGNAL_COLLISION_TEXTS.messageExtractorDisabled, {
-        extractorId: resolution.extractorDisabled.extractorId,
-        loserRaw: signal.raw,
-        loserRange
-      }),
-      data: {
-        extractorDisabled: resolution.extractorDisabled,
-        raw: signal.raw,
-        range: signal.range ?? null
-      }
-    };
-  }
-  if (resolution.belowFloor) {
-    const loserRange = signal.range ? `${signal.range.start}-${signal.range.end}` : "unknown";
-    const topCandidate = signal.candidates[0];
-    return {
-      analyzerId: ID24,
-      severity: "warn",
-      nodeIds: [signal.source],
-      message: tx(SIGNAL_COLLISION_TEXTS.messageBelowFloor, {
-        loserRaw: signal.raw,
-        loserRange,
-        confidence: topCandidate.confidence,
-        threshold: resolution.belowFloor.threshold
-      }),
-      data: {
-        belowFloor: resolution.belowFloor,
-        raw: signal.raw,
-        range: signal.range ?? null
-      }
-    };
-  }
-  return null;
-}
-
-// plugins/core/analyzers/trigger-collision/text.ts
-var TRIGGER_COLLISION_TEXTS = {
-  /**
-   * Top-level message when `analyzeTriggerBucket` accumulated exactly one
-   * cause part. Used for the advertiser-ambiguous-only, invocation-
-   * ambiguous-only, and cross-kind-only branches.
-   */
-  messageOnePart: '"{{normalized}}":\nTrigger collision: {{part}}.',
-  /**
-   * Top-level message when `analyzeTriggerBucket` accumulated two cause
-   * parts (advertiser-ambiguous AND invocation-ambiguous fire together).
-   * The joiner lives inside the template so future locales can adapt it
-   * (e.g. `'; y '` in Spanish) without touching the rule code.
-   */
-  messageTwoParts: '"{{normalized}}":\nTrigger collision: {{first}}; and {{second}}.',
-  /** `<n> advertisers: <list>` part, fires on the advertiser-ambiguous branch. */
-  partAdvertisers: "{{count}} advertisers: {{paths}}",
-  /** `<n> invocation forms: <list>` part, fires on the invocation-ambiguous branch. */
-  partInvocations: "{{count}} invocation forms: {{forms}}",
-  /** Singular cross-kind cause: `non-canonical invocation <form> against advertiser <path>`. */
-  partNonCanonicalSingular: "non-canonical invocation {{forms}} against advertiser {{advertiser}}",
-  /** Plural cross-kind cause: `non-canonical invocations <forms> against advertiser <path>`. */
-  partNonCanonicalPlural: "non-canonical invocations {{forms}} against advertiser {{advertiser}}"
-};
-
-// plugins/core/analyzers/trigger-collision/index.ts
-var ID25 = "trigger-collision";
-var ADVERTISING_KINDS = /* @__PURE__ */ new Set([
-  "command",
-  "skill",
-  "agent"
-]);
-var triggerCollisionAnalyzer = {
-  id: ID25,
-  pluginId: CORE_PLUGIN_ID,
-  kind: "analyzer",
-  mode: "deterministic",
-  description: "Flags two or more nodes that claim the same `/command` or `@agent` name.",
-  // Two claim-collection passes (advertisement + invocation) feeding
-  // the bucket map. Per-bucket analysis lives in `analyzeTriggerBucket`.
-  // eslint-disable-next-line complexity
-  evaluate(ctx) {
-    const buckets = /* @__PURE__ */ new Map();
-    const push = (key, claim) => {
-      const bucket = buckets.get(key) ?? [];
-      bucket.push(claim);
-      buckets.set(key, bucket);
-    };
-    for (const node of ctx.nodes) {
-      if (!ADVERTISING_KINDS.has(node.kind)) continue;
-      const raw = node.frontmatter?.["name"];
-      if (typeof raw !== "string" || raw.length === 0) continue;
-      const normalized = `/${normalizeTrigger(raw)}`;
-      if (normalized === "/") continue;
-      push(normalized, {
-        kind: "advertiser",
-        token: node.path,
-        nodeId: node.path,
-        canonicalForm: `/${raw}`
-      });
-    }
-    for (const link of ctx.links) {
-      const normalized = link.trigger?.normalizedTrigger;
-      if (!normalized) continue;
-      push(normalized, {
-        kind: "invocation",
-        token: link.target,
-        nodeId: link.source
-      });
-    }
-    const issues = [];
-    for (const [normalized, claims] of buckets) {
-      const issue = analyzeTriggerBucket(normalized, claims);
-      if (issue) issues.push(issue);
-    }
-    return issues;
-  }
-};
-function analyzeTriggerBucket(normalized, claims) {
-  const advertiserPaths = [
-    ...new Set(claims.filter((c) => c.kind === "advertiser").map((c) => c.token))
-  ].sort();
-  const invocationTargets = [
-    ...new Set(claims.filter((c) => c.kind === "invocation").map((c) => c.token))
-  ].sort();
-  const advertisers = claims.filter(
-    (c) => c.kind === "advertiser"
-  );
-  const advertiserAmbiguous = advertiserPaths.length >= 2;
-  const invocationAmbiguous = invocationTargets.length >= 2;
-  const canonicalForms = new Set(advertisers.map((a) => a.canonicalForm));
-  const nonCanonicalInvocations = invocationTargets.filter((t) => !canonicalForms.has(t));
-  const crossKindAmbiguous = advertiserPaths.length === 1 && nonCanonicalInvocations.length >= 1;
-  if (!advertiserAmbiguous && !invocationAmbiguous && !crossKindAmbiguous) {
-    return null;
-  }
-  const nodeIds = [...new Set(claims.map((c) => c.nodeId))].sort();
-  const parts = [];
-  if (advertiserAmbiguous) {
-    parts.push(
-      tx(TRIGGER_COLLISION_TEXTS.partAdvertisers, {
-        count: advertiserPaths.length,
-        paths: advertiserPaths.join(", ")
-      })
-    );
-  }
-  if (invocationAmbiguous) {
-    parts.push(
-      tx(TRIGGER_COLLISION_TEXTS.partInvocations, {
-        count: invocationTargets.length,
-        forms: invocationTargets.join(", ")
-      })
-    );
-  } else if (crossKindAmbiguous) {
-    const template = nonCanonicalInvocations.length > 1 ? TRIGGER_COLLISION_TEXTS.partNonCanonicalPlural : TRIGGER_COLLISION_TEXTS.partNonCanonicalSingular;
-    parts.push(
-      tx(template, {
-        forms: nonCanonicalInvocations.join(", "),
-        advertiser: advertiserPaths[0]
-      })
-    );
-  }
-  const message = parts.length === 2 ? tx(TRIGGER_COLLISION_TEXTS.messageTwoParts, {
-    normalized,
-    first: parts[0],
-    second: parts[1]
-  }) : tx(TRIGGER_COLLISION_TEXTS.messageOnePart, {
-    normalized,
-    part: parts[0]
-  });
+function toLinkForSchema(link) {
   return {
-    analyzerId: ID25,
-    severity: "error",
-    nodeIds,
-    message,
-    data: {
-      normalizedTrigger: normalized,
-      invocationTargets,
-      advertiserPaths
-    }
+    source: link.source,
+    target: link.target,
+    kind: link.kind,
+    confidence: link.confidence,
+    sources: link.sources,
+    trigger: link.trigger ?? void 0,
+    location: link.location ?? void 0,
+    raw: link.raw ?? void 0
   };
 }
 
@@ -3770,13 +3555,13 @@ var ASCII_FORMATTER_TEXTS = {
 };
 
 // plugins/core/formatters/ascii/index.ts
-var ID26 = "ascii";
+var ID25 = "ascii";
 var KIND_ORDER = ["agent", "command", "skill", "markdown"];
 var asciiFormatter = {
-  id: ID26,
+  id: ID25,
   pluginId: CORE_PLUGIN_ID,
   kind: "formatter",
-  formatId: ID26,
+  formatId: ID25,
   description: "Renders the scan as plain text in three sections: nodes (grouped by kind), arrows, and issues. Used by `sm scan --format ascii`.",
   // ASCII tree formatter, header + per-kind sections + per-issue
   // section. Each section iterates and renders; splitting per section
@@ -3870,13 +3655,13 @@ function renderSection(out, kind, group) {
 }
 
 // plugins/core/formatters/json/index.ts
-var ID27 = "json";
+var ID26 = "json";
 var jsonFormatter = {
-  id: ID27,
+  id: ID26,
   pluginId: CORE_PLUGIN_ID,
   kind: "formatter",
   description: "Renders the persisted scan as JSON (conforms to `scan-result.schema.json`). Used by `sm graph --format json` and `GET /api/graph?format=json`.",
-  formatId: ID27,
+  formatId: ID26,
   format(ctx) {
     if (ctx.scanResult !== void 0) {
       return JSON.stringify(ctx.scanResult);
@@ -3891,7 +3676,7 @@ var jsonFormatter = {
 
 // kernel/sidecar/parse.ts
 import { existsSync, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname3, resolve as resolve5 } from "path";
+import { dirname as dirname3, resolve as resolve4 } from "path";
 import { createRequire as createRequire3 } from "module";
 import { Ajv2020 as Ajv20203 } from "ajv/dist/2020.js";
 import yaml from "js-yaml";
@@ -3993,10 +3778,10 @@ function getSidecarValidator() {
   applyAjvFormats(ajv);
   const specRoot = resolveSpecRoot2();
   const annotationsSchema = JSON.parse(
-    readFileSync3(resolve5(specRoot, "schemas/annotations.schema.json"), "utf8")
+    readFileSync3(resolve4(specRoot, "schemas/annotations.schema.json"), "utf8")
   );
   const sidecarSchema = JSON.parse(
-    readFileSync3(resolve5(specRoot, "schemas/sidecar.schema.json"), "utf8")
+    readFileSync3(resolve4(specRoot, "schemas/sidecar.schema.json"), "utf8")
   );
   ajv.addSchema(annotationsSchema);
   cachedSidecarValidator = ajv.compile(sidecarSchema);
@@ -4023,13 +3808,13 @@ var BUMP_TEXTS = {
 };
 
 // plugins/core/actions/node-bump/index.ts
-var ID28 = "node-bump";
+var ID27 = "node-bump";
 var bumpButton = {
   slot: "inspector.action.button",
   priority: 10
 };
 var nodeBumpAction = {
-  id: ID28,
+  id: ID27,
   pluginId: CORE_PLUGIN_ID,
   kind: "action",
   description: "Marks a node as updated: bumps `annotations.version`, refreshes sidecar hashes, and records the timestamp.",
@@ -4109,9 +3894,9 @@ function pickCurrentVersion(overlay) {
 
 // plugins/core/actions/node-set-stability/index.ts
 var STABILITY_VALUES = ["experimental", "stable", "deprecated"];
-var ID29 = "node-set-stability";
+var ID28 = "node-set-stability";
 var nodeSetStabilityAction = {
-  id: ID29,
+  id: ID28,
   pluginId: CORE_PLUGIN_ID,
   kind: "action",
   description: "Sets the lifecycle stage of the current node (writes `stability` to the sidecar).",
@@ -4159,13 +3944,13 @@ var TAGS_TEXTS = {
 };
 
 // plugins/core/actions/node-set-tags/index.ts
-var ID30 = "node-set-tags";
+var ID29 = "node-set-tags";
 var setTagsButton = {
   slot: "inspector.action.button",
   priority: 15
 };
 var nodeSetTagsAction = {
-  id: ID30,
+  id: ID29,
   pluginId: CORE_PLUGIN_ID,
   kind: "action",
   description: "Sets the taxonomy tags of the current node (writes `tags` to the sidecar; whole-array replace).",
@@ -4242,13 +4027,13 @@ var SUPERSEDE_TEXTS = {
 };
 
 // plugins/core/actions/node-supersede/index.ts
-var ID31 = "node-supersede";
+var ID30 = "node-supersede";
 var supersedeButton = {
   slot: "inspector.action.button",
   priority: 10
 };
 var nodeSupersedeAction = {
-  id: ID31,
+  id: ID30,
   pluginId: CORE_PLUGIN_ID,
   kind: "action",
   description: "Declares the current node as superseded by another (writes `supersededBy` to the sidecar).",
@@ -4536,7 +4321,7 @@ function writeJsonAtomic(path, content) {
 }
 
 // core/paths/db-path.ts
-import { join as join2, resolve as resolve6 } from "path";
+import { join as join2, resolve as resolve5 } from "path";
 
 // kernel/util/skill-map-paths.ts
 import { join } from "path";
@@ -4564,17 +4349,17 @@ var GITIGNORE_ENTRIES = [
   `${SKILL_MAP_DIR}/${DB_FILENAME}`
 ];
 function resolveDbPath(options) {
-  if (options.db) return resolve6(options.db);
-  return resolve6(options.cwd, DEFAULT_DB_REL);
+  if (options.db) return resolve5(options.db);
+  return resolve5(options.cwd, DEFAULT_DB_REL);
 }
 function defaultProjectDbPath(ctx) {
-  return resolve6(ctx.cwd, DEFAULT_DB_REL);
+  return resolve5(ctx.cwd, DEFAULT_DB_REL);
 }
 function defaultProjectJobsDir(ctx) {
-  return resolve6(ctx.cwd, SKILL_MAP_DIR, JOBS_DIRNAME);
+  return resolve5(ctx.cwd, SKILL_MAP_DIR, JOBS_DIRNAME);
 }
 function defaultProjectPluginsDir(ctx) {
-  return resolve6(ctx.cwd, SKILL_MAP_DIR, PLUGINS_DIRNAME);
+  return resolve5(ctx.cwd, SKILL_MAP_DIR, PLUGINS_DIRNAME);
 }
 function defaultDbPath(scopeRoot) {
   return join2(scopeRoot, SKILL_MAP_DIR, DB_FILENAME);
@@ -4823,19 +4608,18 @@ var annotationFieldUnknownAnalyzer2 = { ...annotationFieldUnknownAnalyzer, plugi
 var annotationOrphanAnalyzer2 = { ...annotationOrphanAnalyzer, pluginId: "core", version: VERSION };
 var annotationStaleAnalyzer2 = { ...annotationStaleAnalyzer, pluginId: "core", version: VERSION };
 var contributionOrphanAnalyzer2 = { ...contributionOrphanAnalyzer, pluginId: "core", version: VERSION };
+var extractorCollisionAnalyzer2 = { ...extractorCollisionAnalyzer, pluginId: "core", version: VERSION };
 var issueCounterAnalyzer2 = { ...issueCounterAnalyzer, pluginId: "core", version: VERSION };
-var jobFileOrphanAnalyzer2 = { ...jobFileOrphanAnalyzer, pluginId: "core", version: VERSION };
-var linkConflictAnalyzer2 = { ...linkConflictAnalyzer, pluginId: "core", version: VERSION };
 var linkCounterAnalyzer2 = { ...linkCounterAnalyzer, pluginId: "core", version: VERSION };
+var linkKindConflictAnalyzer2 = { ...linkKindConflictAnalyzer, pluginId: "core", version: VERSION };
 var linkSelfLoopAnalyzer2 = { ...linkSelfLoopAnalyzer, pluginId: "core", version: VERSION };
+var nameCollisionAnalyzer2 = { ...nameCollisionAnalyzer, pluginId: "core", version: VERSION };
 var nameReservedAnalyzer2 = { ...nameReservedAnalyzer, pluginId: "core", version: VERSION };
 var nodeStabilityAnalyzer2 = { ...nodeStabilityAnalyzer, pluginId: "core", version: VERSION };
 var nodeSupersededAnalyzer2 = { ...nodeSupersededAnalyzer, pluginId: "core", version: VERSION };
 var referenceBrokenAnalyzer2 = { ...referenceBrokenAnalyzer, pluginId: "core", version: VERSION };
 var referenceRedundantAnalyzer2 = { ...referenceRedundantAnalyzer, pluginId: "core", version: VERSION };
 var schemaViolationAnalyzer2 = { ...schemaViolationAnalyzer, pluginId: "core", version: VERSION };
-var signalCollisionAnalyzer2 = { ...signalCollisionAnalyzer, pluginId: "core", version: VERSION };
-var triggerCollisionAnalyzer2 = { ...triggerCollisionAnalyzer, pluginId: "core", version: VERSION };
 var asciiFormatter2 = { ...asciiFormatter, pluginId: "core", version: VERSION };
 var jsonFormatter2 = { ...jsonFormatter, pluginId: "core", version: VERSION };
 var nodeBumpAction2 = { ...nodeBumpAction, pluginId: "core", version: VERSION };
@@ -4889,19 +4673,18 @@ var builtInPlugins = [
       annotationOrphanAnalyzer2,
       annotationStaleAnalyzer2,
       contributionOrphanAnalyzer2,
+      extractorCollisionAnalyzer2,
       issueCounterAnalyzer2,
-      jobFileOrphanAnalyzer2,
-      linkConflictAnalyzer2,
       linkCounterAnalyzer2,
+      linkKindConflictAnalyzer2,
       linkSelfLoopAnalyzer2,
+      nameCollisionAnalyzer2,
       nameReservedAnalyzer2,
       nodeStabilityAnalyzer2,
       nodeSupersededAnalyzer2,
       referenceBrokenAnalyzer2,
       referenceRedundantAnalyzer2,
       schemaViolationAnalyzer2,
-      signalCollisionAnalyzer2,
-      triggerCollisionAnalyzer2,
       asciiFormatter2,
       jsonFormatter2,
       nodeBumpAction2,
@@ -5720,7 +5503,7 @@ import { Command as Command2, Option as Option2 } from "clipanion";
 
 // core/config/helper.ts
 import { homedir as osHomedir } from "os";
-import { isAbsolute, join as join4, resolve as resolve7, sep } from "path";
+import { isAbsolute, join as join4, resolve as resolve6, sep } from "path";
 
 // kernel/config/loader.ts
 import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
@@ -6138,13 +5921,13 @@ function projectPathExposure(inputs) {
   return { expandsSurface: true, exposedPaths: exposed };
 }
 function resolveScanPathForExposure(raw, cwd) {
-  if (raw.startsWith("~/")) return resolve7(join4(osHomedir(), raw.slice(2)));
-  if (raw === "~") return resolve7(osHomedir());
-  if (isAbsolute(raw)) return resolve7(raw);
-  return resolve7(cwd, raw);
+  if (raw.startsWith("~/")) return resolve6(join4(osHomedir(), raw.slice(2)));
+  if (raw === "~") return resolve6(osHomedir());
+  if (isAbsolute(raw)) return resolve6(raw);
+  return resolve6(cwd, raw);
 }
 function isUnderProject(absPath, cwd) {
-  const projectRoot = resolve7(cwd);
+  const projectRoot = resolve6(cwd);
   return absPath === projectRoot || absPath.startsWith(`${projectRoot}${sep}`);
 }
 
@@ -6185,7 +5968,7 @@ function ensureSidecarWritesAllowed(opts) {
 
 // kernel/sidecar/store.ts
 import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname5, resolve as resolve8 } from "path";
+import { dirname as dirname5, resolve as resolve7 } from "path";
 import { createRequire as createRequire4 } from "module";
 import { Ajv2020 as Ajv20204 } from "ajv/dist/2020.js";
 import yaml2 from "js-yaml";
@@ -6293,10 +6076,10 @@ function getSidecarValidator2() {
   applyAjvFormats(ajv);
   const specRoot = resolveSpecRoot3();
   const annotationsSchema = JSON.parse(
-    readFileSync7(resolve8(specRoot, "schemas/annotations.schema.json"), "utf8")
+    readFileSync7(resolve7(specRoot, "schemas/annotations.schema.json"), "utf8")
   );
   const sidecarSchema = JSON.parse(
-    readFileSync7(resolve8(specRoot, "schemas/sidecar.schema.json"), "utf8")
+    readFileSync7(resolve7(specRoot, "schemas/sidecar.schema.json"), "utf8")
   );
   ajv.addSchema(annotationsSchema);
   cachedValidator = ajv.compile(sidecarSchema);
@@ -6416,11 +6199,11 @@ async function confirm(question, streams, opts) {
 // cli/util/git.ts
 import { spawnSync } from "child_process";
 import { existsSync as existsSync7 } from "fs";
-import { dirname as dirname6, resolve as resolve9 } from "path";
+import { dirname as dirname6, resolve as resolve8 } from "path";
 function isInsideGitRepo(cwd) {
   let current = cwd;
   while (true) {
-    if (existsSync7(resolve9(current, ".git"))) return true;
+    if (existsSync7(resolve8(current, ".git"))) return true;
     const parent = dirname6(current);
     if (parent === current) return false;
     current = parent;
@@ -6619,7 +6402,7 @@ import { existsSync as existsSync11 } from "fs";
 
 // kernel/adapters/sqlite/storage-adapter.ts
 import { mkdirSync as mkdirSync4 } from "fs";
-import { dirname as dirname8, resolve as resolve12 } from "path";
+import { dirname as dirname8, resolve as resolve11 } from "path";
 import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 import { CamelCasePlugin, Kysely, sql as sql3 } from "kysely";
 
@@ -7178,7 +6961,7 @@ async function migrateNodeFavorites(trx, fromPath, toPath, report) {
 }
 
 // kernel/adapters/sqlite/jobs.ts
-import { resolve as resolve10 } from "path";
+import { resolve as resolve9 } from "path";
 async function pruneTerminalJobs(db, status, cutoffMs) {
   const rows = await db.selectFrom("state_jobs").select(["id", "filePath"]).where("status", "=", status).where("finishedAt", "is not", null).where("finishedAt", "<", cutoffMs).execute();
   if (rows.length === 0) {
@@ -7193,14 +6976,14 @@ async function selectReferencedJobFilePaths(db) {
   const rows = await db.selectFrom("state_jobs").select(["filePath"]).where("filePath", "is not", null).execute();
   const out = /* @__PURE__ */ new Set();
   for (const row of rows) {
-    if (row.filePath !== null) out.add(resolve10(row.filePath));
+    if (row.filePath !== null) out.add(resolve9(row.filePath));
   }
   return out;
 }
 
 // kernel/adapters/sqlite/migrations.ts
 import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync8, readdirSync } from "fs";
-import { dirname as dirname7, join as join5, resolve as resolve11 } from "path";
+import { dirname as dirname7, join as join5, resolve as resolve10 } from "path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 import { fileURLToPath } from "url";
 
@@ -7215,9 +6998,9 @@ var MIGRATIONS_TEXTS = {
 var FILE_RE = /^(\d{3})_([a-z0-9_]+)\.sql$/;
 function defaultMigrationsDir() {
   const here = dirname7(fileURLToPath(import.meta.url));
-  const flatLayout = resolve11(here, "migrations");
+  const flatLayout = resolve10(here, "migrations");
   if (existsSync8(flatLayout)) return flatLayout;
-  return resolve11(here, "..", "..", "..", "migrations");
+  return resolve10(here, "..", "..", "..", "migrations");
 }
 function discoverMigrations(dir = defaultMigrationsDir()) {
   if (!existsSync8(dir)) return [];
@@ -7287,7 +7070,7 @@ function resolveMigrationTarget(to, files) {
 function writePreMigrateBackup(dbPath, target) {
   return writeBackup(
     dbPath,
-    join5(dirname7(resolve11(dbPath)), "backups", `skill-map-pre-migrate-v${target}.db`)
+    join5(dirname7(resolve10(dbPath)), "backups", `skill-map-pre-migrate-v${target}.db`)
   );
 }
 function applyOneMigration(db, migration) {
@@ -7322,8 +7105,8 @@ function applyOneMigration(db, migration) {
 }
 function writeBackup(dbPath, destPath) {
   if (dbPath === ":memory:") return null;
-  const absoluteSource = resolve11(dbPath);
-  const absoluteDest = resolve11(destPath);
+  const absoluteSource = resolve10(dbPath);
+  const absoluteDest = resolve10(destPath);
   mkdirSync3(dirname7(absoluteDest), { recursive: true });
   const db = new DatabaseSync2(absoluteSource);
   try {
@@ -8284,6 +8067,36 @@ function rowToContribution(row) {
   };
 }
 
+// kernel/adapters/sqlite/link-scores.ts
+async function replaceAllScanLinkScores(trx, linkScores) {
+  await trx.deleteFrom("scan_link_scores").execute();
+  if (linkScores.length === 0) return;
+  const CHUNK = 90;
+  for (let i = 0; i < linkScores.length; i += CHUNK) {
+    const slice = linkScores.slice(i, i + CHUNK);
+    const rows = slice.map(adjustmentToRow);
+    await trx.insertInto("scan_link_scores").values(rows).execute();
+  }
+}
+function adjustmentToRow(adj) {
+  return {
+    pluginId: adj.pluginId,
+    extensionId: adj.extensionId,
+    sourcePath: adj.link.source,
+    target: adj.link.target,
+    kind: adj.link.kind,
+    normalizedTrigger: adj.link.trigger?.normalizedTrigger ?? null,
+    opKind: adj.op.kind,
+    opValue: adj.op.value,
+    // FOLDED final confidence: by the time this writer runs, the
+    // orchestrator has already applied every buffered op into
+    // `link.confidence` (see `applyConfidenceAdjustments`). Denormalised
+    // per row so the audit read needs no join.
+    resultConfidence: adj.link.confidence,
+    emittedAt: Date.now()
+  };
+}
+
 // kernel/adapters/sqlite/schema-fingerprint.ts
 import { createHash } from "crypto";
 import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
@@ -8370,8 +8183,18 @@ async function findNodesByTag(db, tag) {
 }
 
 // kernel/adapters/sqlite/scan-persistence.ts
-async function persistScanResult(db, result, renameOps = [], extractorRuns = [], enrichments = [], contributions = [], registeredContributionKeys = /* @__PURE__ */ new Set(), freshlyRunTuples = /* @__PURE__ */ new Set(), contributionErrors = []) {
+async function persistScanResult(db, result, inputs = {}) {
   const scannedAt = validateScannedAt(result.scannedAt);
+  const {
+    renameOps,
+    extractorRuns,
+    enrichments,
+    contributions,
+    registeredContributionKeys,
+    freshlyRunTuples,
+    contributionErrors,
+    linkScores
+  } = resolvePersistInputs(inputs);
   const renames = [];
   await db.transaction().execute(async (trx) => {
     await applyRenames(trx, renameOps, renames);
@@ -8386,6 +8209,7 @@ async function persistScanResult(db, result, renameOps = [], extractorRuns = [],
       freshlyRunTuples
     );
     await replaceAllScanContributionErrors(trx, contributionErrors);
+    await replaceAllScanLinkScores(trx, linkScores);
     const tagRecords = nodesToTagRecords(result.nodes);
     await replaceAllScanTags(trx, tagRecords, livePathsForContrib);
     await upsertEnrichmentLayer(trx, result, renameOps, enrichments);
@@ -8394,6 +8218,19 @@ async function persistScanResult(db, result, renameOps = [], extractorRuns = [],
   await sql2`PRAGMA wal_checkpoint(TRUNCATE)`.execute(db);
   return { renames };
 }
+function resolvePersistInputs(inputs) {
+  return {
+    renameOps: [],
+    extractorRuns: [],
+    enrichments: [],
+    contributions: [],
+    registeredContributionKeys: /* @__PURE__ */ new Set(),
+    freshlyRunTuples: /* @__PURE__ */ new Set(),
+    contributionErrors: [],
+    linkScores: [],
+    ...inputs
+  };
+}
 function validateScannedAt(scannedAt) {
   if (!Number.isInteger(scannedAt) || scannedAt < 0) {
     throw new Error(
@@ -8762,7 +8599,7 @@ var SqliteStorageAdapter = class {
     if (this.#db) return;
     const path = this.#options.databasePath;
     if (path !== ":memory:") {
-      const absolute = resolve12(path);
+      const absolute = resolve11(path);
       mkdirSync4(dirname8(absolute), { recursive: true });
     }
     if (this.#options.autoMigrate !== false) {
@@ -8899,17 +8736,7 @@ var SqliteStorageAdapter = class {
 };
 async function persistScansThroughNonTx(db, result, opts) {
   const defaults = applyPersistDefaults(opts);
-  await persistScanResult(
-    db,
-    result,
-    defaults.renameOps,
-    defaults.extractorRuns,
-    defaults.enrichments,
-    defaults.contributions,
-    defaults.registeredContributionKeys,
-    defaults.freshlyRunTuples,
-    defaults.contributionErrors
-  );
+  await persistScanResult(db, result, defaults);
 }
 function applyPersistDefaults(opts) {
   return {
@@ -8920,6 +8747,7 @@ function applyPersistDefaults(opts) {
     registeredContributionKeys: /* @__PURE__ */ new Set(),
     freshlyRunTuples: /* @__PURE__ */ new Set(),
     contributionErrors: [],
+    linkScores: [],
     ...opts
   };
 }
@@ -9076,17 +8904,7 @@ function buildTxSubset(trx) {
     scans: {
       persist: (result, opts) => {
         const d = applyPersistDefaults(opts);
-        return persistScanResult(
-          trx,
-          result,
-          d.renameOps,
-          d.extractorRuns,
-          d.enrichments,
-          d.contributions,
-          d.registeredContributionKeys,
-          d.freshlyRunTuples,
-          d.contributionErrors
-        ).then(() => void 0);
+        return persistScanResult(trx, result, d).then(() => void 0);
       }
     },
     issues: {
@@ -9380,16 +9198,16 @@ async function tryWithSqlite(options, fn) {
 }
 
 // cli/commands/bump-plan.ts
-import { resolve as resolve14 } from "path";
+import { resolve as resolve13 } from "path";
 
 // core/paths/path-guard.ts
 import { lstatSync } from "fs";
-import { isAbsolute as isAbsolute2, resolve as resolve13, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute2, resolve as resolve12, sep as sep2 } from "path";
 function assertContained(cwd, rel) {
   if (isAbsolute2(rel)) {
     throw new Error(`node path is absolute, refusing to read: ${rel}`);
   }
-  const abs = resolve13(cwd, rel);
+  const abs = resolve12(cwd, rel);
   if (abs !== cwd && !abs.startsWith(cwd + sep2)) {
     throw new Error(`node path escapes repo root: ${rel}`);
   }
@@ -9424,7 +9242,7 @@ function planOne(node, options, invoker) {
   let absPath;
   try {
     assertContained(options.cwd, node.path);
-    absPath = resolve14(options.cwd, node.path);
+    absPath = resolve13(options.cwd, node.path);
   } catch (err) {
     return {
       nodePath: node.path,
@@ -10047,18 +9865,18 @@ var PLUGIN_LOADER_TEXTS = {
 // kernel/adapters/plugin-loader/index.ts
 import { createRequire as createRequire5 } from "module";
 import { existsSync as existsSync13, readFileSync as readFileSync13, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
-import { join as join8, resolve as resolve17 } from "path";
+import { join as join8, resolve as resolve16 } from "path";
 import { pathToFileURL } from "url";
 import semver from "semver";
 
 // kernel/adapters/plugin-loader/id-utils.ts
-import { isAbsolute as isAbsolute3, relative, resolve as resolve15 } from "path";
+import { isAbsolute as isAbsolute3, relative, resolve as resolve14 } from "path";
 function fail(path, id, status, reason) {
   return { path, id, status, reason };
 }
 function isInsidePlugin(pluginPath, relEntry) {
   if (isAbsolute3(relEntry)) return false;
-  const abs = resolve15(pluginPath, relEntry);
+  const abs = resolve14(pluginPath, relEntry);
   const rel = relative(pluginPath, abs);
   if (rel === "") return true;
   if (rel.startsWith("..")) return false;
@@ -10399,7 +10217,7 @@ function isDirectorySafe(path, statSync12) {
 
 // kernel/adapters/plugin-loader/storage-schemas.ts
 import { readFileSync as readFileSync12 } from "fs";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve15 } from "path";
 import { Ajv2020 as Ajv20206 } from "ajv/dist/2020.js";
 
 // kernel/adapters/plugin-store.ts
@@ -10463,7 +10281,7 @@ function compilePluginSchema(pluginPath, relPath) {
       errDescription: tx(PLUGIN_LOADER_TEXTS.loadErrorSchemaPathEscapesPlugin, { relPath, pluginPath })
     };
   }
-  const abs = resolve16(pluginPath, relPath);
+  const abs = resolve15(pluginPath, relPath);
   let raw;
   try {
     raw = JSON.parse(readFileSync12(abs, "utf8"));
@@ -10505,7 +10323,7 @@ var PluginLoader = class {
         if (!entry.isDirectory()) continue;
         const candidate = join8(root, entry.name);
         if (existsSync13(join8(candidate, "plugin.json"))) {
-          out.push(resolve17(candidate));
+          out.push(resolve16(candidate));
         }
       }
     }
@@ -10664,7 +10482,7 @@ var PluginLoader = class {
         manifest
       } };
     }
-    const abs = resolve17(pluginPath, relEntry);
+    const abs = resolve16(pluginPath, relEntry);
     if (!existsSync13(abs)) {
       return { ok: false, failure: {
         ...fail(
@@ -10868,7 +10686,7 @@ function discoverExtensionEntries(pluginPath) {
   return out;
 }
 function collectKindEntries(pluginPath, kindDir, out) {
-  const kindAbs = resolve17(pluginPath, kindDir);
+  const kindAbs = resolve16(pluginPath, kindDir);
   if (!existsSync13(kindAbs)) return;
   let entries;
   try {
@@ -10879,7 +10697,7 @@ function collectKindEntries(pluginPath, kindDir, out) {
   entries.sort();
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const entryAbs = resolve17(kindAbs, entry);
+    const entryAbs = resolve16(kindAbs, entry);
     if (!isDirectorySafe2(entryAbs)) continue;
     const candidate = findIndexCandidate(entryAbs);
     if (candidate !== null) {
@@ -10896,14 +10714,14 @@ function isDirectorySafe2(path) {
 }
 function findIndexCandidate(entryAbs) {
   for (const candidate of INDEX_CANDIDATES) {
-    if (existsSync13(resolve17(entryAbs, candidate))) return candidate;
+    if (existsSync13(resolve16(entryAbs, candidate))) return candidate;
   }
   return null;
 }
 function installedSpecVersion() {
   const require2 = createRequire5(import.meta.url);
   const indexPath = require2.resolve("@skill-map/spec/index.json");
-  const pkgPath = resolve17(indexPath, "..", "package.json");
+  const pkgPath = resolve16(indexPath, "..", "package.json");
   const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
   return pkg.version;
 }
@@ -11003,7 +10821,7 @@ import { join as join9, relative as relative2, sep as sep3 } from "path";
 
 // kernel/scan/ignore.ts
 import { existsSync as existsSync14, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname10, resolve as resolve18 } from "path";
+import { dirname as dirname10, resolve as resolve17 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import ignoreFactory from "ignore";
 function buildIgnoreFilter(opts = {}) {
@@ -11032,7 +10850,7 @@ function loadBundledIgnoreText() {
   return loadDefaultsText();
 }
 function readIgnoreFileText(scopeRoot) {
-  const path = resolve18(scopeRoot, ".skillmapignore");
+  const path = resolve17(scopeRoot, ".skillmapignore");
   if (!existsSync14(path)) return void 0;
   try {
     return readFileSync14(path, "utf8");
@@ -11061,11 +10879,11 @@ function loadDefaultsText() {
 function readDefaultsFromDisk() {
   const here = dirname10(fileURLToPath2(import.meta.url));
   const candidates = [
-    resolve18(here, "../../config/defaults/skillmapignore"),
+    resolve17(here, "../../config/defaults/skillmapignore"),
     // src/kernel/scan/ → src/config/defaults/
-    resolve18(here, "../config/defaults/skillmapignore"),
+    resolve17(here, "../config/defaults/skillmapignore"),
     // dist/cli.js → dist/config/defaults/ (siblings)
-    resolve18(here, "config/defaults/skillmapignore")
+    resolve17(here, "config/defaults/skillmapignore")
   ];
   for (const candidate of candidates) {
     if (existsSync14(candidate)) {
@@ -11362,7 +11180,7 @@ function isExtensionInstance(v) {
 }
 
 // core/runtime/plugin-runtime/warnings.ts
-import { resolve as resolve19 } from "path";
+import { resolve as resolve18 } from "path";
 
 // kernel/util/text.ts
 function truncateHead(s, max) {
@@ -11412,7 +11230,7 @@ function resolveRuntimeContext(opts) {
   return opts.runtimeContext ?? defaultRuntimeContext();
 }
 function resolveSearchPaths(opts, ctx) {
-  if (opts.pluginDir) return [resolve19(opts.pluginDir)];
+  if (opts.pluginDir) return [resolve18(opts.pluginDir)];
   return [defaultProjectPluginsDir(ctx)];
 }
 
@@ -12679,7 +12497,7 @@ var CONFIG_COMMANDS = [
 
 // cli/commands/conformance.ts
 import { existsSync as existsSync19, readFileSync as readFileSync16 } from "fs";
-import { dirname as dirname12, resolve as resolve22 } from "path";
+import { dirname as dirname12, resolve as resolve21 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { Command as Command5, Option as Option5 } from "clipanion";
 
@@ -12687,7 +12505,7 @@ import { Command as Command5, Option as Option5 } from "clipanion";
 import { spawnSync as spawnSync2 } from "child_process";
 import { cpSync, existsSync as existsSync17, mkdtempSync, readdirSync as readdirSync5, readFileSync as readFileSync15, rmSync, statSync as statSync3 } from "fs";
 import { tmpdir } from "os";
-import { isAbsolute as isAbsolute5, join as join11, relative as relative3, resolve as resolve20 } from "path";
+import { isAbsolute as isAbsolute5, join as join11, relative as relative3, resolve as resolve19 } from "path";
 
 // conformance/i18n/runner.texts.ts
 var CONFORMANCE_RUNNER_TEXTS = {
@@ -12854,7 +12672,7 @@ function assertContained2(root, rel, label) {
       tx(CONFORMANCE_RUNNER_TEXTS.pathMustBeRelative, { label, path: rel, anchor: root })
     );
   }
-  const abs = resolve20(root, rel);
+  const abs = resolve19(root, rel);
   const r = relative3(root, abs);
   if (r.startsWith("..") || isAbsolute5(r)) {
     throw new Error(
@@ -12881,7 +12699,7 @@ function evaluateAssertion(a, ctx) {
       } catch (err) {
         return { ok: false, type: a.type, reason: formatErrorMessage(err) };
       }
-      const abs = resolve20(ctx.scope, a.path);
+      const abs = resolve19(ctx.scope, a.path);
       return existsSync17(abs) ? { ok: true, type: a.type } : {
         ok: false,
         type: a.type,
@@ -12896,7 +12714,7 @@ function evaluateAssertion(a, ctx) {
         return { ok: false, type: a.type, reason: formatErrorMessage(err) };
       }
       const fixturePath = join11(ctx.fixturesRoot, a.fixture);
-      const targetPath = resolve20(ctx.scope, a.path);
+      const targetPath = resolve19(ctx.scope, a.path);
       if (!existsSync17(targetPath)) {
         return {
           ok: false,
@@ -13079,7 +12897,7 @@ var CONFORMANCE_TEXTS = {
 
 // cli/util/conformance-scopes.ts
 import { existsSync as existsSync18, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
-import { dirname as dirname11, resolve as resolve21 } from "path";
+import { dirname as dirname11, resolve as resolve20 } from "path";
 import { createRequire as createRequire6 } from "module";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function resolveSpecRoot4() {
@@ -13097,7 +12915,7 @@ function resolveCliWorkspaceRoot() {
   const here = dirname11(fileURLToPath3(import.meta.url));
   let cursor = here;
   for (let depth = 0; depth < 6; depth += 1) {
-    const candidate = resolve21(cursor, "plugins");
+    const candidate = resolve20(cursor, "plugins");
     if (existsSync18(candidate) && statSync4(candidate).isDirectory()) {
       return cursor;
     }
@@ -13117,12 +12935,12 @@ function collectProviderScopes(specRoot) {
   } catch {
     return out;
   }
-  const pluginsRoot = resolve21(workspaceRoot, "plugins");
+  const pluginsRoot = resolve20(workspaceRoot, "plugins");
   if (!existsSync18(pluginsRoot)) return out;
   for (const pluginEntry of readdirSync6(pluginsRoot)) {
-    const pluginDir = resolve21(pluginsRoot, pluginEntry);
+    const pluginDir = resolve20(pluginsRoot, pluginEntry);
     if (!isDir(pluginDir)) continue;
-    const providersRoot = resolve21(pluginDir, "providers");
+    const providersRoot = resolve20(pluginDir, "providers");
     if (!isDir(providersRoot)) continue;
     collectPluginProviderScopes(providersRoot, specRoot, out);
   }
@@ -13137,12 +12955,12 @@ function isDir(path) {
 }
 function collectPluginProviderScopes(providersRoot, specRoot, out) {
   for (const entry of readdirSync6(providersRoot)) {
-    const providerDir = resolve21(providersRoot, entry);
+    const providerDir = resolve20(providersRoot, entry);
     if (!isDir(providerDir)) continue;
-    const conformanceDir = resolve21(providerDir, "conformance");
+    const conformanceDir = resolve20(providerDir, "conformance");
     if (!existsSync18(conformanceDir)) continue;
-    const casesDir = resolve21(conformanceDir, "cases");
-    const fixturesDir = resolve21(conformanceDir, "fixtures");
+    const casesDir = resolve20(conformanceDir, "cases");
+    const fixturesDir = resolve20(conformanceDir, "fixtures");
     if (!existsSync18(casesDir) || !existsSync18(fixturesDir)) continue;
     out.push({
       id: `provider:${entry}`,
@@ -13159,8 +12977,8 @@ function specScope(specRoot) {
     id: "spec",
     kind: "spec",
     label: "spec",
-    casesDir: resolve21(specRoot, "conformance", "cases"),
-    fixturesDir: resolve21(specRoot, "conformance", "fixtures"),
+    casesDir: resolve20(specRoot, "conformance", "cases"),
+    fixturesDir: resolve20(specRoot, "conformance", "fixtures"),
     specRoot
   };
 }
@@ -13182,7 +13000,7 @@ function selectConformanceScopes(scope) {
 }
 function listCaseFiles(scope) {
   if (!existsSync18(scope.casesDir)) return [];
-  return readdirSync6(scope.casesDir).filter((entry) => entry.endsWith(".json")).sort().map((entry) => resolve21(scope.casesDir, entry));
+  return readdirSync6(scope.casesDir).filter((entry) => entry.endsWith(".json")).sort().map((entry) => resolve20(scope.casesDir, entry));
 }
 
 // cli/commands/conformance.ts
@@ -13199,13 +13017,13 @@ function resolveBinary() {
   const here = dirname12(fileURLToPath4(import.meta.url));
   let cursor = here;
   for (let depth = 0; depth < 6; depth += 1) {
-    const candidate = resolve22(cursor, "bin", "sm.js");
+    const candidate = resolve21(cursor, "bin", "sm.js");
     if (existsSync19(candidate)) return candidate;
     const parent = dirname12(cursor);
     if (parent === cursor) break;
     cursor = parent;
   }
-  return resolve22(here, "..", "..", "bin", "sm.js");
+  return resolve21(here, "..", "..", "bin", "sm.js");
 }
 var ConformanceRunCommand = class extends SmCommand {
   static paths = [["conformance", "run"]];
@@ -13458,7 +13276,7 @@ function writeStreamSnippet(stream, header, text) {
 var CONFORMANCE_COMMANDS = [ConformanceRunCommand];
 
 // cli/commands/db/backup.ts
-import { dirname as dirname13, join as join12, resolve as resolve23 } from "path";
+import { dirname as dirname13, join as join12, resolve as resolve22 } from "path";
 import { Command as Command6, Option as Option6 } from "clipanion";
 
 // cli/i18n/db.texts.ts
@@ -13571,7 +13389,7 @@ var DbBackupCommand = class extends SmCommand {
     const exit = requireDbOrExit(path, this.context.stderr);
     if (exit !== null) return exit;
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const outPath = this.out ? resolve23(this.out) : join12(dirname13(path), "backups", `${ts}.db`);
+    const outPath = this.out ? resolve22(this.out) : join12(dirname13(path), "backups", `${ts}.db`);
     await withSqlite({ databasePath: path, autoMigrate: false }, async (storage) => {
       storage.migrations.writeBackup(outPath);
     });
@@ -13588,7 +13406,7 @@ var DbBackupCommand = class extends SmCommand {
 
 // cli/commands/db/restore.ts
 import { chmod, copyFile, mkdir, rm } from "fs/promises";
-import { dirname as dirname14, resolve as resolve24 } from "path";
+import { dirname as dirname14, resolve as resolve23 } from "path";
 import { Command as Command7, Option as Option7 } from "clipanion";
 
 // cli/util/fs.ts
@@ -13638,7 +13456,7 @@ var DbRestoreCommand = class extends SmCommand {
   });
   async run() {
     const target = resolveDbPath({ db: this.db, ...defaultRuntimeContext() });
-    const sourcePath = resolve24(this.source);
+    const sourcePath = resolve23(this.source);
     const stderrAnsi = this.ansiFor("stderr");
     const sourceStat = await statOrNull(sourcePath);
     if (!sourceStat) {
@@ -13879,7 +13697,7 @@ var DbShellCommand = class extends SmCommand {
 
 // cli/commands/db/browser.ts
 import { spawn, spawnSync as spawnSync4 } from "child_process";
-import { resolve as resolve25 } from "path";
+import { resolve as resolve24 } from "path";
 import { Command as Command10, Option as Option9 } from "clipanion";
 var DbBrowserCommand = class extends SmCommand {
   static paths = [["db", "browser"]];
@@ -13912,7 +13730,7 @@ var DbBrowserCommand = class extends SmCommand {
   });
   positional = Option9.String({ required: false });
   async run() {
-    const path = this.positional ? resolve25(this.positional) : resolveDbPath({ db: this.db, ...defaultRuntimeContext() });
+    const path = this.positional ? resolve24(this.positional) : resolveDbPath({ db: this.db, ...defaultRuntimeContext() });
     if (!assertDbExists(path, this.context.stderr)) {
       this.printer.error(DB_TEXTS.browserRunScanFirstHint);
       return ExitCode.NotFound;
@@ -14830,7 +14648,7 @@ var GraphCommand = class extends SmCommand {
 // cli/commands/help.ts
 import { readFileSync as readFileSync17 } from "fs";
 import { createRequire as createRequire7 } from "module";
-import { resolve as resolve26 } from "path";
+import { resolve as resolve25 } from "path";
 import { Command as Command15, Option as Option14 } from "clipanion";
 
 // cli/i18n/help.texts.ts
@@ -15144,7 +14962,7 @@ function resolveSpecVersion() {
   try {
     const req = createRequire7(import.meta.url);
     const indexPath = req.resolve("@skill-map/spec/index.json");
-    const pkgPath = resolve26(indexPath, "..", "package.json");
+    const pkgPath = resolve25(indexPath, "..", "package.json");
     const pkg = JSON.parse(readFileSync17(pkgPath, "utf8"));
     return pkg.version;
   } catch {
@@ -15452,7 +15270,7 @@ function registeredVerbPaths(cli2) {
 
 // cli/commands/hooks.ts
 import { chmod as chmod2, mkdir as mkdir3, readFile as readFile2, stat as stat2, writeFile } from "fs/promises";
-import { dirname as dirname16, resolve as resolve27 } from "path";
+import { dirname as dirname16, resolve as resolve26 } from "path";
 import { Command as Command16, Option as Option15 } from "clipanion";
 
 // cli/i18n/hooks.texts.ts
@@ -15555,8 +15373,8 @@ var HooksInstallCommand = class extends SmCommand {
       );
       return ExitCode.NotFound;
     }
-    const hooksDir = resolve27(repoRoot, ".git", "hooks");
-    const hookPath = resolve27(hooksDir, "pre-commit");
+    const hooksDir = resolve26(repoRoot, ".git", "hooks");
+    const hookPath = resolve26(hooksDir, "pre-commit");
     const existing = await pathExists(hookPath) ? await readFile2(hookPath, "utf8") : null;
     const planned2 = computePlannedHookContent(existing);
     if (planned2.kind === "already-installed") {
@@ -15614,7 +15432,7 @@ var HooksInstallCommand = class extends SmCommand {
 async function findGitRepoRoot(cwd) {
   let current = cwd;
   while (true) {
-    if (await pathExists(resolve27(current, ".git"))) return current;
+    if (await pathExists(resolve26(current, ".git"))) return current;
     const parent = dirname16(current);
     if (parent === current) return null;
     current = parent;
@@ -15636,7 +15454,7 @@ var HOOKS_COMMANDS = [HooksInstallCommand];
 
 // cli/commands/init.ts
 import { mkdir as mkdir4, readFile as readFile3, unlink, writeFile as writeFile2 } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join16 } from "path";
 import { Command as Command17, Option as Option16 } from "clipanion";
 
 // kernel/orchestrator/index.ts
@@ -16129,8 +15947,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 = [];
@@ -16141,7 +16000,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 qualifiedId2 = qualifiedExtensionId(analyzer.pluginId, analyzer.id);
     const declaredContributions = readDeclaredContributionRefs(analyzer);
     const emitContribution = (nodePath, ref, payload) => {
@@ -16204,6 +16072,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,
@@ -16215,7 +16093,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
@@ -16225,7 +16102,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) {
@@ -16236,13 +16115,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;
@@ -16293,17 +16175,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;
@@ -16452,6 +16323,157 @@ function classifyLinkSource(source, shortIdToQualified, cachedQualifiedIds, appl
   return "obsolete";
 }
 
+// kernel/orchestrator/node-identifiers.ts
+import { posix as pathPosix4 } from "path";
+function deriveNodeIdentifiers(node, kindDescriptor) {
+  const sources = kindDescriptor?.identifiers;
+  if (!sources || sources.length === 0) return [];
+  const out = [];
+  for (const source of sources) {
+    const raw = readIdentifier(source, node);
+    if (!raw) continue;
+    const normalised = normalizeTrigger(raw);
+    if (normalised) out.push(normalised);
+  }
+  return out;
+}
+function readIdentifier(source, node) {
+  if (source === "frontmatter.name") return readFrontmatterName(node);
+  if (source === "filename-basename") return readFilenameBasename(node);
+  return readDirname(node);
+}
+function readFrontmatterName(node) {
+  const raw = node.frontmatter?.["name"];
+  if (typeof raw !== "string") return null;
+  return raw.length > 0 ? raw : null;
+}
+function readFilenameBasename(node) {
+  const base = pathPosix4.basename(node.path);
+  if (!base) return null;
+  const ext = pathPosix4.extname(base);
+  const stem = ext ? base.slice(0, -ext.length) : base;
+  return stem.length > 0 ? stem : null;
+}
+function readDirname(node) {
+  const dir = pathPosix4.dirname(node.path);
+  if (!dir || dir === "." || dir === "/") return null;
+  const base = pathPosix4.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
+function liftResolvedLinkConfidence(links, nodes, ctx) {
+  if (links.length === 0) return;
+  const indexes = buildIndexes(nodes, ctx);
+  for (const link of links) {
+    link.confidence = 1;
+    applyResolution(link, indexes, ctx);
+  }
+}
+function collectBrokenLinks(links, nodes, ctx) {
+  const broken = /* @__PURE__ */ new Set();
+  if (links.length === 0) return broken;
+  const indexes = buildIndexes(nodes, ctx);
+  for (const link of links) {
+    if (isGenuinelyBroken(link, indexes)) broken.add(link);
+  }
+  return broken;
+}
+function applyResolution(link, indexes, ctx) {
+  const resolution = resolve27(link, indexes, ctx);
+  if (resolution === "none") return;
+  link.resolvedTarget = resolution;
+}
+function buildIndexes(nodes, ctx) {
+  const byPath3 = /* @__PURE__ */ new Set();
+  const byName = /* @__PURE__ */ new Map();
+  const nodeByPath = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    byPath3.add(node.path);
+    nodeByPath.set(node.path, node);
+    indexNode(node, ctx, byName);
+  }
+  return { byPath: byPath3, byName, nodeByPath };
+}
+function resolve27(link, indexes, ctx) {
+  if (indexes.byPath.has(link.target)) return link.target;
+  return resolveByName(link, indexes, ctx);
+}
+function isGenuinelyBroken(link, indexes) {
+  if (indexes.byPath.has(link.target)) return false;
+  const stripped = stripTriggerSigil(link.trigger?.normalizedTrigger);
+  if (stripped !== null && indexes.byName.has(stripped)) return false;
+  return true;
+}
+function resolveByName(link, indexes, ctx) {
+  const stripped = stripTriggerSigil(link.trigger?.normalizedTrigger);
+  if (stripped === null) return "none";
+  const candidates = indexes.byName.get(stripped);
+  if (!candidates?.length) return "none";
+  const allowedKinds = lookupAllowedKinds(link, indexes, ctx);
+  if (!allowedKinds?.length) return "none";
+  const winner = candidates.find((c) => allowedKinds.includes(c.kind));
+  return winner ? winner.path : "none";
+}
+function lookupAllowedKinds(link, _indexes, ctx) {
+  if (ctx.activeProvider === null) return void 0;
+  return ctx.providerResolution.get(ctx.activeProvider)?.[link.kind];
+}
+function stripTriggerSigil(normalized) {
+  if (!normalized) return null;
+  const trimmed = normalized.replace(/^[/@]/, "").trim();
+  return trimmed.length === 0 ? null : trimmed;
+}
+function indexNode(node, ctx, byName) {
+  const kindDescriptor = ctx.kindRegistry.get(kindKey(node));
+  const normalised = deriveNodeIdentifiers(node, kindDescriptor);
+  for (const name of normalised) {
+    const entry = { kind: node.kind, path: node.path };
+    const bucket = byName.get(name);
+    if (bucket) {
+      bucket.push(entry);
+    } else {
+      byName.set(name, [entry]);
+    }
+  }
+}
+function kindKey(node) {
+  return `${node.provider}/${node.kind}`;
+}
+
 // kernel/orchestrator/post-walk-transforms.ts
 var POST_WALK_TRANSFORMS = [
   {
@@ -17448,6 +17470,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);
@@ -17462,7 +17485,6 @@ async function runScanInternal(_kernel, options) {
     walked.sidecarRoots,
     options.annotationContributions ?? [],
     options.viewContributions ?? [],
-    options.orphanJobFiles ?? [],
     options.referenceablePaths,
     options.cwd,
     registeredActionIds,
@@ -17470,6 +17492,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
@@ -17492,7 +17515,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);
@@ -17620,7 +17643,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,
@@ -17642,6 +17665,7 @@ function buildScanReturn(walked, issues, renameOps, stats, options, setup) {
     enrichments: walked.enrichments,
     contributions: walked.contributions,
     contributionErrors: walked.contributionErrors,
+    linkScores,
     freshlyRunTuples: walked.freshlyRunTuples
   };
 }
@@ -17887,33 +17911,6 @@ function createKernel() {
   };
 }
 
-// kernel/jobs/orphan-files.ts
-import { readdirSync as readdirSync8, statSync as statSync7 } from "fs";
-import { join as join14, resolve as resolve30 } from "path";
-function findOrphanJobFiles(jobsDir, referencedPaths) {
-  let entries;
-  try {
-    const stat3 = statSync7(jobsDir);
-    if (!stat3.isDirectory()) {
-      return { orphanFilePaths: [], referencedCount: referencedPaths.size };
-    }
-    entries = readdirSync8(jobsDir, { withFileTypes: true });
-  } catch {
-    return { orphanFilePaths: [], referencedCount: referencedPaths.size };
-  }
-  const orphans = [];
-  for (const entry of entries) {
-    if (entry.isSymbolicLink()) continue;
-    if (!entry.isFile()) continue;
-    const name = entry.name;
-    if (!name.endsWith(".md")) continue;
-    const abs = resolve30(join14(jobsDir, name));
-    if (!referencedPaths.has(abs)) orphans.push(abs);
-  }
-  orphans.sort();
-  return { orphanFilePaths: orphans, referencedCount: referencedPaths.size };
-}
-
 // core/config/plugin-settings.ts
 var defaultWarn = (message) => log.warn(message);
 function resolveExtensionSettings(manifest, config, onWarn = defaultWarn) {
@@ -18218,9 +18215,9 @@ function resolveScanRoots(inputs) {
 }
 
 // core/runtime/reference-paths-walker.ts
-import { readdirSync as readdirSync9, statSync as statSync8 } from "fs";
+import { readdirSync as readdirSync8, statSync as statSync7 } from "fs";
 import { homedir as osHomedir2 } from "os";
-import { isAbsolute as isAbsolute8, join as join15, resolve as resolve31 } from "path";
+import { isAbsolute as isAbsolute8, join as join14, resolve as resolve30 } from "path";
 var REFERENCE_WALK_MAX_FILES = 5e4;
 var SKIPPED_DIR_NAMES = /* @__PURE__ */ new Set([
   "node_modules",
@@ -18228,10 +18225,10 @@ var SKIPPED_DIR_NAMES = /* @__PURE__ */ new Set([
   SKILL_MAP_DIR
 ]);
 function resolveScanPath(raw, cwd) {
-  if (raw.startsWith("~/")) return resolve31(join15(osHomedir2(), raw.slice(2)));
-  if (raw === "~") return resolve31(osHomedir2());
-  if (isAbsolute8(raw)) return resolve31(raw);
-  return resolve31(cwd, raw);
+  if (raw.startsWith("~/")) return resolve30(join14(osHomedir2(), raw.slice(2)));
+  if (raw === "~") return resolve30(osHomedir2());
+  if (isAbsolute8(raw)) return resolve30(raw);
+  return resolve30(cwd, raw);
 }
 function walkReferencePaths(rawRoots, cwd) {
   const paths = /* @__PURE__ */ new Set();
@@ -18253,14 +18250,14 @@ function walkInto(dir, out) {
   if (out.size >= REFERENCE_WALK_MAX_FILES) return true;
   let entries;
   try {
-    entries = readdirSync9(dir, { withFileTypes: true });
+    entries = readdirSync8(dir, { withFileTypes: true });
   } catch {
     return false;
   }
   for (const entry of entries) {
     if (out.size >= REFERENCE_WALK_MAX_FILES) return true;
     if (entry.isSymbolicLink()) continue;
-    const full = join15(dir, entry.name);
+    const full = join14(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIPPED_DIR_NAMES.has(entry.name)) continue;
       if (walkInto(full, out)) return true;
@@ -18272,7 +18269,7 @@ function walkInto(dir, out) {
 }
 function safeStat(path) {
   try {
-    return statSync8(path);
+    return statSync7(path);
   } catch {
     return null;
   }
@@ -18280,7 +18277,7 @@ function safeStat(path) {
 
 // core/runtime/active-provider-bootstrap.ts
 import { createInterface as createInterface3 } from "readline";
-import { isAbsolute as isAbsolute9, join as join16 } from "path";
+import { isAbsolute as isAbsolute9, join as join15 } from "path";
 async function bootstrapActiveProvider(opts) {
   const fromCwd = resolveActiveProvider(opts.cwd, opts.providers);
   if (fromCwd.source === "config") {
@@ -18339,7 +18336,7 @@ function aggregateDetected(cwd, effectiveRoots, cwdDetected, providers) {
     out.push(id);
   }
   for (const root of effectiveRoots) {
-    const absRoot = isAbsolute9(root) ? root : join16(cwd, root);
+    const absRoot = isAbsolute9(root) ? root : join15(cwd, root);
     const r = resolveActiveProvider(absRoot, providers);
     for (const id of r.detected) {
       if (seen.has(id)) continue;
@@ -18578,7 +18575,6 @@ async function runScanForCommand(opts) {
     emitReferenceWalkAdvisory(walk3, opts);
   }
   const loadPrior = makePriorLoader(opts.noBuiltIns, strict);
-  const jobsDir = defaultProjectJobsDir(ctx);
   const lens = await resolveActiveLens(
     opts,
     ctx,
@@ -18603,7 +18599,7 @@ async function runScanForCommand(opts) {
     cfg.tokenizer
   );
   const willPersist = !opts.noBuiltIns && !opts.dryRun;
-  const scanned = await (willPersist ? runPersistPath(opts, dbPath, jobsDir, strict, loadPrior, runScanWith, extensions) : runEphemeralPath(opts, dbPath, strict, loadPrior, runScanWith));
+  const scanned = await (willPersist ? runPersistPath(opts, dbPath, strict, loadPrior, runScanWith, extensions) : runEphemeralPath(opts, dbPath, strict, loadPrior, runScanWith));
   return scanned.kind === "ok" ? { ...scanned, lensAutoDetected: lens.autoDetected } : scanned;
 }
 function detectionProviders(extensions) {
@@ -18716,7 +18712,7 @@ function makePriorLoader(noBuiltIns, strict) {
   };
 }
 function makeScanRunner(kernel, opts, effectiveRoots, ignoreFilter, strict, extensions, referenceablePaths, scanCwd, activeProvider, recommendedNodeLimit, maxFileSizeBytes, tokenizer) {
-  return async (prior, priorExtractorRuns, orphanJobFiles) => {
+  return async (prior, priorExtractorRuns) => {
     if (opts.changed && prior === null) {
       opts.stderr.write(SCAN_RUNNER_TEXTS.changedNoPriorWarning);
     }
@@ -18733,14 +18729,13 @@ function makeScanRunner(kernel, opts, effectiveRoots, ignoreFilter, strict, exte
       recommendedNodeLimit,
       maxFileSizeBytes,
       tokenizer,
-      ...priorExtractorRuns ? { priorExtractorRuns } : {},
-      ...orphanJobFiles ? { orphanJobFiles } : {}
+      ...priorExtractorRuns ? { priorExtractorRuns } : {}
     });
     return runScanWithRenames(kernel, runOptions);
   };
 }
 function buildRunScanOptions(args2) {
-  const { opts, prior, priorExtractorRuns, orphanJobFiles, referenceablePaths } = args2;
+  const { opts, prior, priorExtractorRuns, referenceablePaths } = args2;
   const runOptions = {
     roots: args2.effectiveRoots.slice(),
     tokenize: !opts.noTokens,
@@ -18748,11 +18743,6 @@ function buildRunScanOptions(args2) {
     ignoreFilter: args2.ignoreFilter,
     strict: args2.strict,
     emitter: buildRunScanEmitter(opts),
-    // Orphan job-file detection, empty list means "no orphans
-    // visible from this caller" (legacy behaviour). The orchestrator
-    // defaults to `[]` when the field is absent; we always pass the
-    // array (possibly empty) to keep the wiring uniform.
-    orphanJobFiles: orphanJobFiles ?? [],
     activeProvider: args2.activeProvider,
     recommendedNodeLimit: args2.recommendedNodeLimit,
     overrideMaxNodes: opts.maxNodes ?? null,
@@ -18795,7 +18785,7 @@ async function rebuildOnDrift(opts, dbPath) {
     })
   };
 }
-async function runPersistPath(opts, dbPath, jobsDir, strict, loadPrior, runScanWith, extensions) {
+async function runPersistPath(opts, dbPath, strict, loadPrior, runScanWith, extensions) {
   const driftError = await rebuildOnDrift(opts, dbPath);
   if (driftError) return driftError;
   let outcome;
@@ -18803,11 +18793,9 @@ async function runPersistPath(opts, dbPath, jobsDir, strict, loadPrior, runScanW
     outcome = await withSqlite({ databasePath: dbPath }, async (adapter) => {
       const prior = await loadPrior(adapter);
       const priorExtractorRuns = opts.changed && prior ? await adapter.scans.loadExtractorRuns() : void 0;
-      const referencedJobFiles = await adapter.jobs.listReferencedFilePaths();
-      const orphanJobFiles = findOrphanJobFiles(jobsDir, referencedJobFiles).orphanFilePaths;
       let scanned;
       try {
-        scanned = await runScanWith(prior, priorExtractorRuns, orphanJobFiles);
+        scanned = await runScanWith(prior, priorExtractorRuns);
       } catch (err) {
         return { kind: "scan-error", message: formatErrorMessage(err) };
       }
@@ -18822,6 +18810,7 @@ async function runPersistPath(opts, dbPath, jobsDir, strict, loadPrior, runScanW
         enrichments: scanned.enrichments,
         contributions: scanned.contributions,
         contributionErrors: scanned.contributionErrors,
+        linkScores: scanned.linkScores,
         registeredContributionKeys: collectRegisteredContributionKeys(extensions),
         freshlyRunTuples: scanned.freshlyRunTuples
       });
@@ -18938,7 +18927,7 @@ var InitCommand = class extends SmCommand {
   async run() {
     const ctx = defaultRuntimeContext();
     const scopeRoot = ctx.cwd;
-    const skillMapDir = join17(scopeRoot, SKILL_MAP_DIR);
+    const skillMapDir = join16(scopeRoot, SKILL_MAP_DIR);
     const settingsPath = defaultSettingsPath(scopeRoot);
     const localPath = defaultLocalSettingsPath(scopeRoot);
     const ignorePath = defaultIgnoreFilePath(scopeRoot);
@@ -18984,7 +18973,7 @@ var InitCommand = class extends SmCommand {
     const okGlyph = ansi.green("\u2713");
     const updated = await ensureGitignoreEntries(scopeRoot, GITIGNORE_ENTRIES);
     if (updated) {
-      const gitignorePath = join17(scopeRoot, ".gitignore");
+      const gitignorePath = join16(scopeRoot, ".gitignore");
       printer.info(
         GITIGNORE_ENTRIES.length === 1 ? tx(INIT_TEXTS.gitignoreUpdatedSingular, { glyph: okGlyph, path: gitignorePath }) : tx(INIT_TEXTS.gitignoreUpdatedPlural, {
           glyph: okGlyph,
@@ -19045,7 +19034,7 @@ async function safeUnlink(path) {
 }
 async function writeDryRunGitignorePlan(printer, scopeRoot) {
   const wouldAdd = await previewGitignoreEntries(scopeRoot, GITIGNORE_ENTRIES);
-  const gitignorePath = join17(scopeRoot, ".gitignore");
+  const gitignorePath = join16(scopeRoot, ".gitignore");
   if (wouldAdd.length === 0) {
     printer.info(tx(INIT_TEXTS.dryRunWouldLeaveGitignoreUnchanged, { path: gitignorePath }));
   } else if (wouldAdd.length === 1) {
@@ -19150,7 +19139,7 @@ async function runFirstScan(scopeRoot, strict, printer, stderr, stdin, ansi) {
   return hasErrors ? ExitCode.Issues : ExitCode.Ok;
 }
 async function previewGitignoreEntries(scopeRoot, entries) {
-  const path = join17(scopeRoot, ".gitignore");
+  const path = join16(scopeRoot, ".gitignore");
   const body = await pathExists(path) ? await readFile3(path, "utf8") : "";
   const present = new Set(
     body.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"))
@@ -19158,7 +19147,7 @@ async function previewGitignoreEntries(scopeRoot, entries) {
   return entries.filter((entry) => !present.has(entry));
 }
 async function ensureGitignoreEntries(scopeRoot, entries) {
-  const path = join17(scopeRoot, ".gitignore");
+  const path = join16(scopeRoot, ".gitignore");
   let body = "";
   if (await pathExists(path)) {
     body = await readFile3(path, "utf8");
@@ -19699,6 +19688,33 @@ import { unlink as unlink2 } from "fs/promises";
 import { relative as relative6 } from "path";
 import { Command as Command19, Option as Option18 } from "clipanion";
 
+// kernel/jobs/orphan-files.ts
+import { readdirSync as readdirSync9, statSync as statSync8 } from "fs";
+import { join as join17, resolve as resolve31 } from "path";
+function findOrphanJobFiles(jobsDir, referencedPaths) {
+  let entries;
+  try {
+    const stat3 = statSync8(jobsDir);
+    if (!stat3.isDirectory()) {
+      return { orphanFilePaths: [], referencedCount: referencedPaths.size };
+    }
+    entries = readdirSync9(jobsDir, { withFileTypes: true });
+  } catch {
+    return { orphanFilePaths: [], referencedCount: referencedPaths.size };
+  }
+  const orphans = [];
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    if (!entry.isFile()) continue;
+    const name = entry.name;
+    if (!name.endsWith(".md")) continue;
+    const abs = resolve31(join17(jobsDir, name));
+    if (!referencedPaths.has(abs)) orphans.push(abs);
+  }
+  orphans.sort();
+  return { orphanFilePaths: orphans, referencedCount: referencedPaths.size };
+}
+
 // cli/i18n/jobs.texts.ts
 var JOBS_TEXTS = {
   pruneErrorPrefix: "{{glyph}}  sm job prune: {{message}}\n",
@@ -23899,6 +23915,7 @@ function createWatcherRuntime(opts) {
         enrichments,
         contributions,
         contributionErrors,
+        linkScores,
         freshlyRunTuples
       } = ran;
       await withSqlite(
@@ -23909,6 +23926,7 @@ function createWatcherRuntime(opts) {
           enrichments,
           contributions,
           contributionErrors,
+          linkScores,
           registeredContributionKeys: collectRegisteredContributionKeys(composed),
           freshlyRunTuples
         })
@@ -24391,7 +24409,7 @@ var ScanCommand = class extends SmCommand {
     details: `
       Walks the given roots with the built-in claude Provider, runs the
       frontmatter / slash / at-directive / external-url-counter
-      extractors per node, then the trigger-collision / broken-ref /
+      extractors per node, then the name-collision / broken-ref /
       superseded analyzers over the full graph. Emits a ScanResult
       conforming to scan-result.schema.json.
 
@@ -28494,6 +28512,43 @@ var WsBroadcaster = class {
   }
 };
 
+// server/heartbeat.ts
+var WS_HEARTBEAT_INTERVAL_MS = 3e4;
+function startWsHeartbeat(wss, opts = {}) {
+  const intervalMs = opts.intervalMs ?? WS_HEARTBEAT_INTERVAL_MS;
+  const alive = /* @__PURE__ */ new WeakMap();
+  const onConnection = (socket) => {
+    alive.set(socket, true);
+    socket.on("pong", () => {
+      alive.set(socket, true);
+    });
+  };
+  wss.on("connection", onConnection);
+  const timer = setInterval(() => {
+    for (const socket of wss.clients) {
+      if (alive.get(socket) === false) {
+        socket.terminate();
+        continue;
+      }
+      alive.set(socket, false);
+      try {
+        socket.ping();
+      } catch {
+      }
+    }
+  }, intervalMs);
+  timer.unref?.();
+  let stopped = false;
+  return {
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(timer);
+      wss.off("connection", onConnection);
+    }
+  };
+}
+
 // server/kind-registry.ts
 function buildKindRegistry(providers) {
   const registry = {};
@@ -28777,6 +28832,7 @@ async function createServer(options, extra = {}) {
   });
   const wss = new WebSocketServer({ noServer: true });
   const server = await listenAsync(app.fetch, wss, options.host, options.port);
+  const heartbeat = startWsHeartbeat(wss);
   const addr = server.address();
   const address = normalizeAddress(addr, options.host, options.port);
   let watcherService = null;
@@ -28810,6 +28866,7 @@ async function createServer(options, extra = {}) {
   const close = async () => {
     if (closed) return;
     closed = true;
+    heartbeat.stop();
     if (watcherService) {
       try {
         await watcherService.stop();
@@ -31152,4 +31209,4 @@ function resolveBareDefault() {
   process.exit(ExitCode.Error);
 }
 //# sourceMappingURL=cli.js.map
-//# debugId=49fdc2af-2694-5cd0-ac19-33f8d1dffa9e
+//# debugId=e6038423-ea97-5e66-b371-0916d382d819