@skill-map/cli 0.56.0 → 0.57.0

package/dist/index.js

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

package/dist/kernel/index.d.ts

@@ -816,6 +816,29 @@ type LinkKind = 'invokes' | 'references' | 'mentions' | 'supersedes' | 'points';
  * enum check. Missing confidence defaults to `ConfidenceTier.MEDIUM`.
  */
 type Confidence = number;
+/**
+ * A single confidence-scoring operation a `score`-phase analyzer
+ * contributes via `ctx.adjustConfidence(link, op)`. The orchestrator
+ * folds every op on a link into the final `confidence` (see
+ * `orchestrator/confidence-score.ts` for the algebra):
+ *   - `set`   hard override (resolved → 1.0, reserved → 0.1)
+ *   - `delta` additive, may be negative (third-party heuristics)
+ *   - `ceil`  upper cap, lowers only (broken → 0.5)
+ *   - `floor` lower bound, raises only
+ */
+type TConfidenceOp = {
+    readonly kind: 'set';
+    readonly value: number;
+} | {
+    readonly kind: 'delta';
+    readonly value: number;
+} | {
+    readonly kind: 'ceil';
+    readonly value: number;
+} | {
+    readonly kind: 'floor';
+    readonly value: number;
+};
 type Severity = 'error' | 'warn' | 'info';
 type Stability = 'experimental' | 'stable' | 'deprecated';
 /**
@@ -1132,11 +1155,10 @@ interface Signal {
      * raw extractor emissions (before the resolver runs). When
      * `outcome === 'materialised'`, `winnerIndex` points into `candidates[]`
      * of the candidate the resolver chose; a corresponding `Link` was added
-     * to the graph. When `outcome === 'rejected'`, one of `rejectedBy` /
-     * `extractorDisabled` / `belowFloor` is set and no Link materialised.
-     * Both materialised and rejected Signals remain on
-     * `IAnalyzerContext.signals` so the `core/signal-collision` analyzer can
-     * surface losers as `warn` issues. Mirrors
+     * to the graph. When `outcome === 'rejected'`, `rejectedBy` is set and
+     * no Link materialised. Both materialised and rejected Signals remain on
+     * `IAnalyzerContext.signals` so the `core/extractor-collision` analyzer
+     * can surface losers as `warn` issues. Mirrors
      * `signal.schema.json#/properties/resolution`.
      */
     resolution?: ISignalResolution;
@@ -1162,24 +1184,6 @@ interface ISignalResolution {
         extractorId: string;
         reason: 'kind-priority' | 'higher-confidence' | 'longer-range' | 'earlier-declaration';
     };
-    /**
-     * Phase 4+ stub: populated when every candidate of this Signal came from
-     * an extractor the operator disabled via
-     * `plugins.<id>.extensions.<extId>.enabled`. Today the resolver never
-     * sets this; documented so analyzer surfaces can be built when the filter
-     * lands.
-     */
-    extractorDisabled?: {
-        extractorId: string;
-    };
-    /**
-     * Phase 4+ stub: populated when every candidate's `confidence` fell below
-     * the configured floor. Today the resolver materialises every Signal that
-     * survives overlap regardless of confidence.
-     */
-    belowFloor?: {
-        threshold: number;
-    };
 }
 interface IssueFix {
     summary?: string;
@@ -1679,6 +1683,55 @@ declare function makePluginStore(opts: {
     persistDedicated?: IDedicatedStorePersist;
 }): TPluginStore | undefined;
 
+/**
+ * Combination algebra for plugin-contributed link-confidence adjustments.
+ *
+ * Confidence ([0,1]) starts at the kernel's 1.0 baseline (seeded on every
+ * link by `liftResolvedLinkConfidence`). `score`-phase analyzers then
+ * contribute attributed operations via `ctx.adjustConfidence(link, op)`;
+ * the orchestrator buffers them and folds all ops for a link into a final
+ * value with `foldConfidence`. The kernel dogfoods this exact API through
+ * two built-in score-phase detectors, each co-locating its penalty op
+ * with the finding it reports: `core/name-reserved`
+ * (reserved → `delta -0.9` → 0.1), `core/reference-broken`
+ * (broken → `delta -0.5` → 0.5). A clean-resolved or untouched link folds
+ * to `clamp(base)` and keeps the 1.0 baseline.
+ *
+ * The fold is deterministic and order-independent across the four
+ * buckets (set / delta / floor / ceil are each commutative):
+ *   1. base = the extractor-emitted confidence.
+ *   2. `set`: a hard override. When more than one `set` lands on a link
+ *      the LAST in the caller's canonical order wins (the caller pre-
+ *      sorts ops by `(pluginId, extensionId)` so the winner is stable);
+ *      a single `set` simply replaces the base.
+ *   3. `delta`: additive (may be negative), summed.
+ *   4. `floor`: raise to at least the value (`max`).
+ *   5. `ceil`: lower to at most the value (`min`) — today's broken cap.
+ *      Applied AFTER floor so a cap dominates a floor/ceil collision.
+ *   6. clamp to [0,1] ONCE at the end, so opposing deltas round-trip
+ *      (e.g. `-0.4` then `+0.4` returns to base, never clipped midway).
+ *
+ * A link no scorer touches folds to `clamp(base)` (the kernel's 1.0
+ * baseline), identical to a clean-resolved link. With only the built-in
+ * detectors active a link is at most reserved OR broken (mutually
+ * exclusive), so it gets at most one penalty delta and folds to 0.1 / 0.5
+ * respectively; a clean link keeps the 1.0 base. Third-party scorers layer
+ * additional ops on top, summed deterministically before the single clamp.
+ */
+
+/**
+ * One attributed adjustment, buffered by the orchestrator as a scorer
+ * calls `adjustConfidence`. `link` is held by object identity (the same
+ * link objects flow through the post-walk pipeline). Persisted to
+ * `scan_link_scores` for the "why is this link at X?" audit trail.
+ */
+interface IConfidenceAdjustment {
+    readonly link: Link;
+    readonly pluginId: string;
+    readonly extensionId: string;
+    readonly op: TConfidenceOp;
+}
+
 /**
  * Row-level filter for `port.scans.findNodes(...)` (driven by
  * `sm list`'s flags). All fields are optional, an empty filter
@@ -1727,11 +1780,11 @@ interface INodeCounts {
     issues: number;
 }
 /**
- * Lightweight option bag for `port.scans.persist`. Mirrors the trailing
- * arguments of the legacy `persistScanResult(db, result, renameOps,
- * extractorRuns, enrichments)` free function so the adapter
- * implementation is a one-line delegation today; the named-bag shape
- * tomorrow lets new optional inputs land without breaking callers.
+ * Lightweight option bag for `port.scans.persist`. Mirrors the optional
+ * inputs of the `persistScanResult(db, result, inputs)` free function
+ * (`IPersistScanInputs` in `kernel/adapters/sqlite/scan-persistence.ts`),
+ * so the adapter implementation is a one-line delegation; the named-bag
+ * shape lets new optional inputs land without breaking callers.
  */
 interface IPersistOptions {
     renameOps?: RenameOp[];
@@ -1747,6 +1800,18 @@ interface IPersistOptions {
      * scan clears any stale rows). Surfaced by `sm plugins doctor`.
      */
     contributionErrors?: IContributionErrorRecord[];
+    /**
+     * Per-op confidence-attribution audit trail for `scan_link_scores`.
+     * One entry per attributed `ctx.adjustConfidence(link, op)` call a
+     * `score`-phase analyzer buffered this scan; the orchestrator already
+     * folded them into `link.confidence`, so these rows are the attribution
+     * (which plugin / extension / op moved a given link, plus the folded
+     * `result_confidence`). Plain REPLACE-ALL into `scan_link_scores`
+     * (delete all, then insert), the same posture as `scan_issues`. Empty /
+     * absent wipes the table (a scan whose scorers touched nothing clears
+     * any stale rows).
+     */
+    linkScores?: IConfidenceAdjustment[];
     /**
      * Phase 3 / View contribution system, active runtime catalog of
      * registered view contributions, keyed by qualified id
@@ -2983,18 +3048,6 @@ interface IAnalyzerContext {
      * runScan sites that never wired the catalog through).
      */
     viewContributions?: readonly IRegisteredViewContribution[];
-    /**
-     * Absolute paths of `*.md` files under the project's
-     * `.skill-map/jobs/` that no `state_jobs.filePath` references, the
-     * built-in `core/job-file-orphan` analyzer projects each as a `warn`
-     * issue. Pre-computed by the driving adapter (CLI / BFF) inside its
-     * already-open storage transaction (mirrors the `orphanSidecars`
-     * pattern: detection lives outside the analyzer, the analyzer only
-     * projects). Absent (or empty) when the caller does not maintain a
-     * jobs directory, when the storage path is unavailable, or when no
-     * orphan files exist. Treat as read-only.
-     */
-    orphanJobFiles?: readonly string[];
     /**
      * Issues emitted by analyzers that already ran in the current pass.
      * Lets a late-phase analyzer (`core/issue-counter`) compute
@@ -3051,6 +3104,23 @@ interface IAnalyzerContext {
      * that never wired the field through, the rule then emits nothing.
      */
     brokenLinks?: ReadonlySet<Link>;
+    /**
+     * Names claimed by two or more distinct nodes, keyed by the normalised
+     * name. A node contributes only when its kind declares `frontmatter.name`
+     * as a resolution identifier (so plain `core/markdown` nodes, addressed
+     * by path, never collide) and it carries a non-empty `name`. Names that
+     * normalise to the same value (e.g. `Deploy` / `deploy`) collide, mirroring
+     * how the resolver keys on the normalised identifier. Computed once per
+     * scan by the orchestrator from the same kind registry the resolver uses,
+     * so analyzers project it without re-deriving (the `brokenLinks` /
+     * `reservedNodePaths` precompute-and-project pattern). The single consumer
+     * is `core/name-collision`, which emits one `error` per entry. Absent for
+     * legacy callers that never wired the field through.
+     */
+    nameCollisions?: ReadonlyMap<string, readonly {
+        readonly path: string;
+        readonly kind: string;
+    }[]>;
     /**
      * Absolute path of the scan's project root (cwd of the invocation).
      * Threaded into the analyzer pass so an analyzer that needs to
@@ -3095,6 +3165,17 @@ interface IAnalyzerContext {
      * emissions (`scan_contributions`).
      */
     emitContribution<C extends IViewContribution>(nodePath: string, ref: C, payload: SlotPayload<C['slot']>): void;
+    /**
+     * Contribute a confidence adjustment to a link. Usable ONLY from a
+     * `score`-phase analyzer; the orchestrator records it attributed to
+     * the calling extension (`pluginId` / `extensionId`, like
+     * `emitContribution`) and folds every op on a link into the final
+     * `link.confidence` before the `detect` phase. `link` must be one of
+     * `ctx.links` (matched by object identity). Present ONLY in the
+     * `score` phase (absent for `detect` / `aggregate` and legacy
+     * callers), mirroring the other orchestrator-injected ctx fields.
+     */
+    adjustConfidence?(link: Link, op: TConfidenceOp): void;
 }
 interface IAnalyzer extends IExtensionBase {
     /** Discriminant injected by the loader from the folder structure. */
@@ -3121,22 +3202,31 @@ interface IAnalyzer extends IExtensionBase {
      * Execution phase. Drives the order the orchestrator schedules
      * analyzers in:
      *
+     *   - `'score'`, runs strictly BEFORE every `detect`-phase analyzer.
+     *     The ONLY phase permitted to write: it adjusts link confidence
+     *     via `ctx.adjustConfidence(link, op)`. The orchestrator folds
+     *     every score-phase op into `link.confidence` before the read-
+     *     only `detect` phase runs, so the `detect` analyzers see the
+     *     final value. The kernel seeds the 1.0 confidence baseline on
+     *     every link, then dogfoods this phase via two built-in score-phase
+     *     detectors (`core/name-reserved`, `core/reference-broken`), each
+     *     co-locating its penalty `delta` with the finding it reports.
      *   - `'detect'` (default), the main pass. Walks nodes / links and
-     *     emits its own findings. Most analyzers live here.
+     *     emits its own findings. Most analyzers live here. Read-only.
      *   - `'aggregate'`, runs strictly AFTER every `detect`-phase
      *     analyzer has finished. The orchestrator passes the full
      *     issue accumulator on `ctx.accumulatedIssues`, so an
      *     aggregator can compute cross-analyzer summaries (per-node
      *     severity totals, etc.) without re-reading the persisted DB.
      *     Aggregators emit contributions; emitting issues is allowed
-     *     but uncommon.
+     *     but uncommon. Read-only.
      *
-     * Two-phase scheduling is the clean alternative to ordering
-     * analyzers by hand in the built-ins registry: filesystem-sorted
-     * generators can keep their alphabetical output, the orchestrator
-     * applies the phase sort at run-time.
+     * Phase scheduling is the clean alternative to ordering analyzers by
+     * hand in the built-ins registry: filesystem-sorted generators can
+     * keep their alphabetical output, the orchestrator applies the phase
+     * sort (`score` < `detect` < `aggregate`) at run-time.
      */
-    phase?: 'detect' | 'aggregate';
+    phase?: 'score' | 'detect' | 'aggregate';
     evaluate(ctx: IAnalyzerContext): Issue[] | Promise<Issue[]>;
 }
 
@@ -3921,21 +4011,6 @@ interface RunScanOptions {
      * mock without spinning up a DB.
      */
     pluginStores?: ReadonlyMap<string, TPluginStore>;
-    /**
-     * Pre-computed absolute paths of orphan job MD files (files under
-     * `.skill-map/jobs/` whose absolute path appears nowhere in
-     * `state_jobs.filePath`). Threaded into the rule pass so the
-     * built-in `core/job-file-orphan` rule can project each as a `warn`
-     * issue without the kernel reaching for the storage port or doing
-     * its own FS walk. The driving adapter (CLI, BFF) computes this
-     * inside its already-open storage transaction via
-     * `findOrphanJobFiles(jobsDir, await port.jobs.listReferencedFilePaths())`
-     * mirrors the `orphanSidecars` model where detection lives
-     * outside the rule and the rule only projects. Absent / empty when
-     * the caller has no jobs context (out-of-band tests, fresh DB,
-     * `--no-built-ins`).
-     */
-    orphanJobFiles?: readonly string[];
     /**
      * Side set of absolute file paths the operator opted into for
      * link-validation purposes via `scan.referencePaths`. Threaded
@@ -4019,6 +4094,7 @@ declare function runScanWithRenames(_kernel: Kernel, options: RunScanOptions): P
     enrichments: IEnrichmentRecord[];
     contributions: IContributionRecord[];
     contributionErrors: IContributionErrorRecord[];
+    linkScores: IConfidenceAdjustment[];
     freshlyRunTuples: ReadonlySet<string>;
 }>;
 declare function runScan(_kernel: Kernel, options: RunScanOptions): Promise<ScanResult>;
@@ -4217,7 +4293,7 @@ declare function createChokidarWatcher(opts: ICreateFsWatcherOptions): IFsWatche
  *     a reason narrowing what diverged.
  *
  *   - **Link**: `(source, target, kind, normalizedTrigger ?? '')`. This
- *     mirrors the link-conflict rule and `sm show` aggregation,
+ *     mirrors the link-kind-conflict rule and `sm show` aggregation,
  *     two links with identical endpoints, kind, and (optional) trigger
  *     are the same link, even if emitted by different extractors. The
  *     `sources[]` union and confidence are NOT part of identity; they