vigiles 14.7.0 → 14.9.0

package/dist/core/plugin-dir-layout.js

@@ -12,10 +12,11 @@ exports.pluginDirLayoutIssues = pluginDirLayoutIssues;
  * completely invisible to the harness. Only `plugin.json` belongs inside the
  * manifest directory; everything else must live at the root.
  *
- * Pure + FP-safe: the only IO is an injectable `existsSync` and `isDirectory`
- * (defaults: node:fs), mirroring the pattern in core/skill-resources.ts and the
- * loader, so the detector is fully testable with fakes and never touches the
- * filesystem in tests.
+ * Pure + FP-safe + node-free: the only IO is a REQUIRED, injected `existsSync`
+ * and `isDirectory` (the disk caller passes `node:fs`; the browser engine passes
+ * a map-backed pair), so the detector is fully testable with fakes, never touches
+ * the filesystem in tests, and statically imports no `node:` builtin — it bundles
+ * clean in a browser (path ops come from the node-free `posix-path`).
  *
  * Harness-agnostic: the surface directory names are INJECTED from the layout
  * (PluginLayout.skillDir / agentDir / commandDir / hookDir, or equivalent), never
@@ -23,23 +24,10 @@ exports.pluginDirLayoutIssues = pluginDirLayoutIssues;
  * `plugin-dir-layout` rule) and `vigiles audit` (the read-only report) — one
  * detector, no drift.
  */
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
+const posix_path_js_1 = require("../posix-path.js");
 // ---------------------------------------------------------------------------
 // Detector
 // ---------------------------------------------------------------------------
-/**
- * Default `isDirectory` implementation — wraps statSync so that a missing or
- * unreadable path returns `false` instead of throwing.
- */
-function defaultIsDirectory(p) {
-    try {
-        return (0, node_fs_1.statSync)(p).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
 /**
  * Surface directories found nested INSIDE the manifest directory, where they are
  * invisible to the harness.
@@ -53,12 +41,12 @@ function defaultIsDirectory(p) {
  * dirs.
  */
 function pluginDirLayoutIssues(manifestDir, surfaceDirNames, opts) {
-    const exists = opts?.existsSync ?? node_fs_1.existsSync;
-    const isDir = opts?.isDirectory ?? defaultIsDirectory;
-    const manifestBase = (0, node_path_1.basename)(manifestDir);
+    const exists = opts.existsSync;
+    const isDir = opts.isDirectory;
+    const manifestBase = (0, posix_path_js_1.basename)(manifestDir);
     const findings = [];
     for (const name of surfaceDirNames) {
-        const candidate = (0, node_path_1.join)(manifestDir, name);
+        const candidate = (0, posix_path_js_1.join)(manifestDir, name);
         if (exists(candidate) && isDir(candidate)) {
             findings.push({
                 dir: name,

package/dist/core/proofs.d.ts

@@ -10,6 +10,7 @@
  *   5. MerkleHistory      — tamper-evident spec evolution audit trail
  *   6. propertyTest()     — random mutation + invariant checking
  */
+import { ncd } from "./ncd.js";
 import type { Rule, ClaudeSpec } from "./spec.js";
 export interface MonotonicityViolation {
     ruleId: string;
@@ -49,17 +50,7 @@ export declare function latticeJoin(a: Rule["_kind"], b: Rule["_kind"]): Rule["_
 export declare function latticeMeet(a: Rule["_kind"], b: Rule["_kind"]): Rule["_kind"];
 /** Get the numeric strength of a rule kind. */
 export declare function ruleStrength(kind: Rule["_kind"]): number;
-/**
- * Normalized Compression Distance — information-theoretic similarity.
- *
- *   NCD(x, y) = (C(xy) - min(C(x), C(y))) / max(C(x), C(y))
- *
- * Range: [0, 1+ε] where 0 = identical information content.
- * Deterministic. No model dependency. Approximates the universal distance metric.
- *
- * Reference: Li, Chen, Li, Ma, Vitányi (2004) "The Similarity Metric"
- */
-export declare function ncd(a: string, b: string): number;
+export { ncd };
 export interface NCDPair {
     idA: string;
     idB: string;

package/dist/core/proofs.js

@@ -12,19 +12,19 @@
  *   6. propertyTest()     — random mutation + invariant checking
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MerkleHistory = exports.BloomFilter = void 0;
+exports.MerkleHistory = exports.BloomFilter = exports.ncd = void 0;
 exports.checkMonotonicity = checkMonotonicity;
 exports.latticeJoin = latticeJoin;
 exports.latticeMeet = latticeMeet;
 exports.ruleStrength = ruleStrength;
-exports.ncd = ncd;
 exports.findSimilarRules = findSimilarRules;
 exports.ruleToBloomFilter = ruleToBloomFilter;
 exports.fixedPoint = fixedPoint;
 exports.propertyTest = propertyTest;
 exports.fitness = fitness;
-const node_zlib_1 = require("node:zlib");
 const hash_js_1 = require("./hash.js");
+const ncd_js_1 = require("./ncd.js");
+Object.defineProperty(exports, "ncd", { enumerable: true, get: function () { return ncd_js_1.ncd; } });
 // ---------------------------------------------------------------------------
 // 1. Monotonicity Lattice — partial order on rule strength
 // ---------------------------------------------------------------------------
@@ -127,41 +127,6 @@ function latticeMeet(a, b) {
 function ruleStrength(kind) {
     return STRENGTH[kind];
 }
-// ---------------------------------------------------------------------------
-// 2. Normalized Compression Distance (NCD)
-// ---------------------------------------------------------------------------
-/**
- * Compute the compressed size of a string using gzip.
- * This approximates Kolmogorov complexity — the length of the shortest
- * program that produces the string.
- */
-function compressedSize(s) {
-    return (0, node_zlib_1.gzipSync)(Buffer.from(s, "utf-8"), { level: 9 }).length;
-}
-/**
- * Normalized Compression Distance — information-theoretic similarity.
- *
- *   NCD(x, y) = (C(xy) - min(C(x), C(y))) / max(C(x), C(y))
- *
- * Range: [0, 1+ε] where 0 = identical information content.
- * Deterministic. No model dependency. Approximates the universal distance metric.
- *
- * Reference: Li, Chen, Li, Ma, Vitányi (2004) "The Similarity Metric"
- */
-function ncd(a, b) {
-    if (a === b)
-        return 0;
-    if (a.length === 0 && b.length === 0)
-        return 0;
-    const ca = compressedSize(a);
-    const cb = compressedSize(b);
-    const cab = compressedSize(a + b);
-    const minC = Math.min(ca, cb);
-    const maxC = Math.max(ca, cb);
-    if (maxC === 0)
-        return 0;
-    return (cab - minC) / maxC;
-}
 /**
  * Find all rule pairs with NCD below a similarity threshold.
  * Returns pairs sorted by distance (most similar first).
@@ -175,7 +140,7 @@ function findSimilarRules(rules, threshold = 0.5) {
             const [idB, ruleB] = entries[j];
             const textA = ruleToText(ruleA);
             const textB = ruleToText(ruleB);
-            const d = ncd(textA, textB);
+            const d = (0, ncd_js_1.ncd)(textA, textB);
             if (d < threshold) {
                 pairs.push({ idA, idB, distance: d });
             }

package/dist/core/skill-resources.d.ts

@@ -12,8 +12,8 @@ export interface SkillResourceFinding {
     readonly line: number;
 }
 export interface SkillResourceOptions {
-    /** Injectable existence check (default: node:fs existsSync). */
-    readonly existsSync?: (p: string) => boolean;
+    /** REQUIRED, injected existence check (disk: node:fs existsSync). */
+    readonly existsSync: (p: string) => boolean;
     /**
      * Repo root, used only together with `sharedDirs` (below). Off by default.
      */
@@ -39,5 +39,5 @@ export interface SkillResourceOptions {
  * The shared detector behind both `vigiles lint` (the `skill-resource-resolves`
  * rule) and `vigiles audit` (the read-only report) — one detector, no drift.
  */
-export declare function skillResourceIssues(skillBody: string, skillDir: string, opts?: SkillResourceOptions): SkillResourceFinding[];
+export declare function skillResourceIssues(skillBody: string, skillDir: string, opts: SkillResourceOptions): SkillResourceFinding[];
 //# sourceMappingURL=skill-resources.d.ts.map

package/dist/core/skill-resources.js

@@ -34,11 +34,12 @@ exports.skillResourceIssues = skillResourceIssues;
  * (example / e.g. / such as / would be / template / →). Markdown links are
  * unchanged — a link is already an act-on-it reference. See `inlinePathIsUsed`.
  *
- * Pure: the only IO is an injectable `existsSync` (default node:fs), mirroring
- * core/refs.ts and the loader so the detector is testable with a fake.
+ * Pure + node-free: the only IO is a REQUIRED, injected `existsSync` (the disk
+ * caller passes `node:fs`; the browser engine a map-backed check), so the
+ * detector is testable with a fake and statically imports no `node:` builtin —
+ * it bundles clean in a browser (path ops come from the node-free `posix-path`).
  */
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
+const posix_path_js_1 = require("../posix-path.js");
 // ---------------------------------------------------------------------------
 // Shapes we match vs deliberately skip (FP-safety)
 // ---------------------------------------------------------------------------
@@ -202,19 +203,19 @@ function candidatesInLine(line, lineNo) {
  * The shared detector behind both `vigiles lint` (the `skill-resource-resolves`
  * rule) and `vigiles audit` (the read-only report) — one detector, no drift.
  */
-function skillResourceIssues(skillBody, skillDir, opts = {}) {
-    const exists = opts.existsSync ?? node_fs_1.existsSync;
+function skillResourceIssues(skillBody, skillDir, opts) {
+    const exists = opts.existsSync;
     const sharedDirs = new Set(opts.sharedDirs ?? []);
     // A ref resolves if it exists under the skill's own dir. If (and only if) its
     // first segment is a DECLARED shared dir, it may also resolve against the repo
     // root — the opt-in shared-tree case. No shared dirs → skill-dir-only (unchanged).
     const resolvesAnywhere = (rel) => {
-        if (exists((0, node_path_1.resolve)(skillDir, rel)))
+        if (exists((0, posix_path_js_1.resolve)(skillDir, rel)))
             return true;
         const firstSeg = rel.split("/")[0];
         return (opts.repoRoot !== undefined &&
             sharedDirs.has(firstSeg) &&
-            exists((0, node_path_1.resolve)(opts.repoRoot, rel)));
+            exists((0, posix_path_js_1.resolve)(opts.repoRoot, rel)));
     };
     const findings = [];
     const seen = new Set();

package/dist/leaderboard.d.ts

@@ -10,57 +10,8 @@
  * The behavioural columns (real trigger-rate, observed egress, safety) need a
  * model and stack on top later; this part runs anywhere in CI for free.
  */
-import { type ScanReport } from "./scan.js";
-export interface PluginScore {
-    readonly dir: string;
-    readonly name: string;
-    /** 0–100 structural-health score (100 = no structural issues found). */
-    readonly score: number;
-    readonly grade: "A" | "B" | "C" | "D" | "F";
-    /** Human-readable deductions, worst first. */
-    readonly issues: readonly string[];
-    readonly report: ScanReport;
-}
-export declare const W_MISSING_HOOK = 15;
-export declare const W_NO_DESCRIPTION = 10;
-export declare const W_DANGLING_REF = 8;
-export declare const W_OVERLAP = 8;
-export declare const W_NO_CONTRACT = 5;
-export declare const W_TRIFECTA = 10;
-/** Map a 0–100 structural-health score to its letter grade (A ≥90 … F <60). */
-export declare function gradeFor(score: number): PluginScore["grade"];
-/** One deduction: a count, its per-item weight, and the label if non-zero. */
-export interface Deduction {
-    readonly n: number;
-    readonly weight: number;
-    readonly label: string;
-}
-/**
- * The COMPLETE graded-penalty list a report incurs — the single source of truth
- * BOTH the leaderboard's single health number and the audit's category rings
- * read, so the overall can never drift between the two surfaces. Each entry is a
- * graded penalty; untested surfaces are deliberately ABSENT (they're advisory,
- * surfaced separately, never scored).
- */
-export declare function reportDeductions(r: ScanReport): Deduction[];
-/** True when a report has no loadable plugin surface at all (the empty machine). */
-export declare function isEmptyMachine(r: ScanReport): boolean;
-/**
- * THE shared integrity score — `100 − Σ(all graded penalties)`, clamped to
- * [0,100]. Both the leaderboard's single health number AND the audit's headline
- * overall read this, so the two can never disagree (the summed model is the
- * honest one — averaging rings would dilute a real problem). Returns the score
- * plus the per-item deductions so callers render their own issue/finding lists.
- */
-export declare function computeIntegrityScore(deductions: readonly Deduction[]): {
-    score: number;
-    penalty: number;
-};
-/** Deterministic structural-health score for one scanned plugin. */
-export declare function scoreReport(r: ScanReport): {
-    score: number;
-    issues: string[];
-};
+import { type PluginScore } from "./score-core.js";
+export { type PluginScore, type Deduction, W_MISSING_HOOK, W_NO_DESCRIPTION, W_DANGLING_REF, W_OVERLAP, W_NO_CONTRACT, W_TRIFECTA, gradeFor, reportDeductions, isEmptyMachine, computeIntegrityScore, scoreReport, } from "./score-core.js";
 /** Scan + score each directory, ranked best-first (ties broken by name). */
 export declare function rankPlugins(dirs: readonly string[]): PluginScore[];
 /** Format a ranked leaderboard as human-readable text. */

package/dist/leaderboard.js

@@ -12,18 +12,30 @@
  * model and stack on top later; this part runs anywhere in CI for free.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.W_TRIFECTA = exports.W_NO_CONTRACT = exports.W_OVERLAP = exports.W_DANGLING_REF = exports.W_NO_DESCRIPTION = exports.W_MISSING_HOOK = void 0;
-exports.gradeFor = gradeFor;
-exports.reportDeductions = reportDeductions;
-exports.isEmptyMachine = isEmptyMachine;
-exports.computeIntegrityScore = computeIntegrityScore;
-exports.scoreReport = scoreReport;
+exports.scoreReport = exports.computeIntegrityScore = exports.isEmptyMachine = exports.reportDeductions = exports.gradeFor = exports.W_TRIFECTA = exports.W_NO_CONTRACT = exports.W_OVERLAP = exports.W_DANGLING_REF = exports.W_NO_DESCRIPTION = exports.W_MISSING_HOOK = void 0;
 exports.rankPlugins = rankPlugins;
 exports.formatLeaderboard = formatLeaderboard;
 exports.formatLeaderboardMarkdown = formatLeaderboardMarkdown;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const scan_js_1 = require("./scan.js");
+// The pure, node-free scoring core lives in ./score-core.js (extracted so the
+// in-browser audit's report builder can import scoring WITHOUT this module's
+// node-only scanPlugin/pluginLabel → scan.ts → @ast-grep/napi chain). Re-exported
+// here so every existing `from "./leaderboard.js"` consumer keeps working.
+const score_core_js_1 = require("./score-core.js");
+var score_core_js_2 = require("./score-core.js");
+Object.defineProperty(exports, "W_MISSING_HOOK", { enumerable: true, get: function () { return score_core_js_2.W_MISSING_HOOK; } });
+Object.defineProperty(exports, "W_NO_DESCRIPTION", { enumerable: true, get: function () { return score_core_js_2.W_NO_DESCRIPTION; } });
+Object.defineProperty(exports, "W_DANGLING_REF", { enumerable: true, get: function () { return score_core_js_2.W_DANGLING_REF; } });
+Object.defineProperty(exports, "W_OVERLAP", { enumerable: true, get: function () { return score_core_js_2.W_OVERLAP; } });
+Object.defineProperty(exports, "W_NO_CONTRACT", { enumerable: true, get: function () { return score_core_js_2.W_NO_CONTRACT; } });
+Object.defineProperty(exports, "W_TRIFECTA", { enumerable: true, get: function () { return score_core_js_2.W_TRIFECTA; } });
+Object.defineProperty(exports, "gradeFor", { enumerable: true, get: function () { return score_core_js_2.gradeFor; } });
+Object.defineProperty(exports, "reportDeductions", { enumerable: true, get: function () { return score_core_js_2.reportDeductions; } });
+Object.defineProperty(exports, "isEmptyMachine", { enumerable: true, get: function () { return score_core_js_2.isEmptyMachine; } });
+Object.defineProperty(exports, "computeIntegrityScore", { enumerable: true, get: function () { return score_core_js_2.computeIntegrityScore; } });
+Object.defineProperty(exports, "scoreReport", { enumerable: true, get: function () { return score_core_js_2.scoreReport; } });
 /** The plugin's declared name (`.claude-plugin/plugin.json`), for a real label in
  * the ranking instead of a SHA-pinned dir basename. Falls back to the basename. */
 function pluginLabel(dir) {
@@ -41,233 +53,16 @@ function pluginLabel(dir) {
     }
     return (0, node_path_1.basename)(dir) || dir;
 }
-// Penalty weights — broken-at-runtime costs most, footguns less, nudges least.
-// Exported so the category view (audit-score.ts) reuses the SAME weights and the
-// two surfaces can never drift on a per-item cost.
-exports.W_MISSING_HOOK = 15; // a hook script that doesn't exist → never runs
-exports.W_NO_DESCRIPTION = 10; // a skill with no usable description → can't trigger
-exports.W_DANGLING_REF = 8; // a referenced intra-plugin file that's missing → broken path
-exports.W_OVERLAP = 8; // a description collision → the wrong skill fires
-exports.W_NO_CONTRACT = 5; // generic small-footgun weight (disallowedTools typo, invalid model/color)
-exports.W_TRIFECTA = 10; // a HARD lethal-trifecta contract (all three legs, explicit) → a prompt-injection exfil path. HALF the old 20: a DING, not a fail — a trifecta is a real risk worth surfacing in the grade, but official plugins ship the pattern by design, so it dents the score (e.g. feature-dev's 3 hard units → −30 → C) without a catastrophic F.
-// Two things are advisory, NOT graded penalties (shown, never scored — see scoreReport):
-//   - untested surfaces — a hardening gap, not breakage.
-//   - an agent that inherits all tools (no `tools:` line) — see reportDeductions for why.
-//   - an inherits-all (severity "advisory") trifecta finding — shown by the Safety
-//     ring but never scored; only the HARD, explicit all-three-legs finding grades.
-/** Map a 0–100 structural-health score to its letter grade (A ≥90 … F <60). */
-function gradeFor(score) {
-    if (score >= 90)
-        return "A";
-    if (score >= 80)
-        return "B";
-    if (score >= 70)
-        return "C";
-    if (score >= 60)
-        return "D";
-    return "F";
-}
-/**
- * The COMPLETE graded-penalty list a report incurs — the single source of truth
- * BOTH the leaderboard's single health number and the audit's category rings
- * read, so the overall can never drift between the two surfaces. Each entry is a
- * graded penalty; untested surfaces are deliberately ABSENT (they're advisory,
- * surfaced separately, never scored).
- */
-function reportDeductions(r) {
-    const missingHooks = r.hooks.filter((h) => h.status === "missing").length;
-    const noDesc = r.skills.filter((s) => !s.hasDescription).length;
-    const deadTools = r.agents.reduce((n, a) => n + a.toolIssues.length, 0);
-    const deadMcpTools = r.agents.reduce((n, a) => n + a.mcpToolIssues.length, 0);
-    const deadDisallowed = r.agents.reduce((n, a) => n + a.disallowedToolIssues.length, 0);
-    // HARD lethal-trifecta findings only — an EXPLICIT contract naming all three
-    // legs (a prompt-injection exfil path). Graded at W_TRIFECTA=10 (HALF the old
-    // 20): a DING that surfaces a real risk in the grade without a catastrophic F
-    // for an accepted design pattern official plugins ship. Advisory (inherits-all)
-    // trifecta findings are surfaced but NEVER graded (aligned with the inherits-all
-    // stance), so they're excluded here.
-    const hardTrifecta = r.trifectaFindings.filter((f) => f.finding.severity === "hard").length;
-    return [
-        {
-            n: hardTrifecta,
-            weight: exports.W_TRIFECTA,
-            label: "unit(s) holding all three lethal-trifecta legs (prompt-injection exfil path)",
-        },
-        {
-            n: missingHooks,
-            weight: exports.W_MISSING_HOOK,
-            label: "hook script(s) MISSING",
-        },
-        {
-            n: r.hookEventIssues.length,
-            weight: exports.W_MISSING_HOOK,
-            label: "hook(s) on an unknown event (never fire)",
-        },
-        {
-            n: noDesc,
-            weight: exports.W_NO_DESCRIPTION,
-            label: "skill(s) with no usable description",
-        },
-        {
-            n: r.descriptionOverlaps.length,
-            weight: exports.W_OVERLAP,
-            label: "near-identical skill description(s) (wrong one fires)",
-        },
-        {
-            n: r.danglingRefs.length,
-            weight: exports.W_DANGLING_REF,
-            label: "broken intra-plugin reference(s)",
-        },
-        {
-            n: deadTools,
-            weight: exports.W_DANGLING_REF,
-            label: "unavailable agent tool(s) (typo / never-available)",
-        },
-        {
-            n: deadMcpTools,
-            weight: exports.W_DANGLING_REF,
-            label: "agent MCP tool(s) whose server isn't declared (can't resolve)",
-        },
-        {
-            n: deadDisallowed,
-            weight: exports.W_NO_CONTRACT,
-            label: "agent disallowedTools typo(s) that block nothing",
-        },
-        // NB: an agent that inherits all tools (no `tools:` line) is ADVISORY, not a
-        // graded penalty — it's surfaced by scoreReport / the Structure ring but never
-        // drags the score. WHY: omitting the `tools:` line is a near-universal,
-        // legitimate authoring style (a measured OSS sweep of 122 real plugins found
-        // 109 whose ONLY finding was this), so penalizing it makes the grade cry wolf
-        // on idiomatic subagents. A health score should mean "something is BROKEN", and
-        // a broad-by-default tool surface is a hardening/least-privilege NUDGE, not
-        // breakage. The count is re-derived where the advisory note is built.
-        {
-            n: r.frontmatterIssues.length,
-            weight: exports.W_NO_DESCRIPTION,
-            label: "surface(s) missing required frontmatter (name/description)",
-        },
-        {
-            n: r.frontmatterValueIssues.length,
-            weight: exports.W_NO_CONTRACT,
-            label: "agent(s) with an invalid model/color (typo → silent fallback)",
-        },
-        {
-            n: r.mcpIssues.length,
-            weight: exports.W_DANGLING_REF,
-            label: "MCP server(s) that can't start (no command/url)",
-        },
-        {
-            n: r.mcpHookIssues.length,
-            weight: exports.W_DANGLING_REF,
-            label: "mcp_tool hook(s) incomplete / targeting an undeclared server",
-        },
-        {
-            n: r.skillResourceIssues.length,
-            weight: exports.W_DANGLING_REF,
-            label: "skill bundled-resource ref(s) that don't resolve on disk",
-        },
-        {
-            n: r.skillFenceIssues.length,
-            weight: exports.W_NO_DESCRIPTION,
-            label: "invisible skill(s) (frontmatter with no opening `---` fence)",
-        },
-        {
-            n: r.pluginLayoutIssues.length,
-            weight: exports.W_NO_DESCRIPTION,
-            label: "functional dir(s) misplaced inside `.claude-plugin/` (invisible)",
-        },
-        {
-            n: r.hookBlockFindings.length,
-            weight: exports.W_MISSING_HOOK,
-            label: "hook(s) that look like they block but silently don't",
-        },
-        {
-            n: r.hookMatcherFindings.length,
-            weight: exports.W_MISSING_HOOK,
-            label: "hook matcher(s) that never fire (typo / wrong MCP form)",
-        },
-        // NB: delegationTrifecta (like the advisory per-unit/inherits-all trifecta) is a
-        // ⚠ RISK, surfaced but NOT graded — only the HARD per-unit trifecta above scores.
-        // NB: untested surfaces are NOT a penalty — an untested surface is a hardening
-        // gap, not breakage, so it never drags the health score (it's appended as an
-        // advisory note below). The score ranks what's BROKEN.
-    ];
-}
-/** True when a report has no loadable plugin surface at all (the empty machine). */
-function isEmptyMachine(r) {
-    const surfaces = r.skills.length +
-        r.agents.length +
-        r.hooks.length +
-        r.inlineHooks +
-        r.commands;
-    return surfaces === 0 && !r.mcp;
-}
-/**
- * THE shared integrity score — `100 − Σ(all graded penalties)`, clamped to
- * [0,100]. Both the leaderboard's single health number AND the audit's headline
- * overall read this, so the two can never disagree (the summed model is the
- * honest one — averaging rings would dilute a real problem). Returns the score
- * plus the per-item deductions so callers render their own issue/finding lists.
- */
-function computeIntegrityScore(deductions) {
-    let penalty = 0;
-    for (const d of deductions) {
-        if (d.n <= 0)
-            continue;
-        penalty += d.n * d.weight;
-    }
-    return { score: Math.max(0, 100 - penalty), penalty };
-}
-/** Resolve the terse "thing(s)" plural placeholder against a count:
- * n===1 drops the "(s)" ("1 tool"); otherwise it becomes "s" ("3 tools").
- * (Kept local — audit-score.ts has its own copy to avoid a circular import.) */
-function pluralizeLabel(n, label) {
-    return label.replace(/\(s\)/g, n === 1 ? "" : "s");
-}
-/** Deterministic structural-health score for one scanned plugin. */
-function scoreReport(r) {
-    // An empty/unloadable machine isn't healthy — it's a non-plugin or a broken
-    // load. A command-only or MCP-only plugin (commands/*.md or .mcp.json with no
-    // skills/agents/hooks) IS a legitimate plugin, though — Anthropic ships
-    // command-only plugins in its own marketplace — so it must NOT score 0.
-    const surfaces = r.skills.length + r.agents.length + r.hooks.length + r.commands;
-    if (surfaces === 0 && !r.mcp) {
-        return { score: 0, issues: ["no loadable plugin surface"] };
-    }
-    const deductions = reportDeductions(r);
-    const { score } = computeIntegrityScore(deductions);
-    const issues = [];
-    for (const d of deductions) {
-        if (d.n === 0)
-            continue;
-        issues.push(`${String(d.n)} ${pluralizeLabel(d.n, d.label)}`);
-    }
-    // Sort issues by cost (worst first) so the report leads with what matters.
-    issues.sort((a, b) => Number(b.split(" ")[0]) - Number(a.split(" ")[0]));
-    // Advisory notes are surfaced for visibility but DON'T affect the score, so they
-    // come AFTER the real (score-affecting) issues:
-    //   - inherit-all (no tool contract): a least-privilege NUDGE, not breakage —
-    //     see reportDeductions for the full rationale.
-    //   - untested surfaces: a hardening gap, not breakage.
-    const noContract = r.agents.filter((a) => a.tools === null).length;
-    if (noContract > 0) {
-        issues.push(`${String(noContract)} ${pluralizeLabel(noContract, "agent(s) inherit all tools (no contract) (advisory)")}`);
-    }
-    if (r.untested > 0) {
-        issues.push(`${String(r.untested)} ${pluralizeLabel(r.untested, "untested surface(s) (advisory)")}`);
-    }
-    return { score, issues };
-}
 /** Scan + score each directory, ranked best-first (ties broken by name). */
 function rankPlugins(dirs) {
     const scored = dirs.map((dir) => {
         const report = (0, scan_js_1.scanPlugin)(dir);
-        const { score, issues } = scoreReport(report);
+        const { score, issues } = (0, score_core_js_1.scoreReport)(report);
         return {
             dir,
             name: pluginLabel(dir),
             score,
-            grade: gradeFor(score),
+            grade: (0, score_core_js_1.gradeFor)(score),
             issues,
             report,
         };

package/dist/optimize.d.ts

@@ -26,7 +26,7 @@
  * the ranked fix list + the hand-off to the measured layer. Same findings, the
  * optimization framing. See research/measurement-authority.md (A2) + roadmap §P1.
  */
-import { type PluginScore } from "./leaderboard.js";
+import { type PluginScore } from "./score-core.js";
 import { type ExplanationConfidence } from "./score-explainer.js";
 import type { ScanReport } from "./scan.js";
 /**

package/dist/optimize.js

@@ -31,7 +31,7 @@ exports.formatOptimize = formatOptimize;
  * the ranked fix list + the hand-off to the measured layer. Same findings, the
  * optimization framing. See research/measurement-authority.md (A2) + roadmap §P1.
  */
-const leaderboard_js_1 = require("./leaderboard.js");
+const score_core_js_1 = require("./score-core.js");
 const score_explainer_js_1 = require("./score-explainer.js");
 function actionFor(e) {
     return e.symptom === "wrong-skill-fires" ? "differentiate" : "fix";
@@ -46,7 +46,7 @@ function isEmptyMachine(r) {
  * before `possible` proxies, via explainScore's own ordering). Pure over the report.
  */
 function optimize(report) {
-    const { score } = (0, leaderboard_js_1.scoreReport)(report);
+    const { score } = (0, score_core_js_1.scoreReport)(report);
     const recommendations = (0, score_explainer_js_1.explainScore)(report).map((e) => ({
         surface: e.surface,
         action: actionFor(e),
@@ -58,7 +58,7 @@ function optimize(report) {
     return {
         dir: report.dir,
         score,
-        grade: (0, leaderboard_js_1.gradeFor)(score),
+        grade: (0, score_core_js_1.gradeFor)(score),
         recommendations,
         empty: isEmptyMachine(report),
     };

package/dist/posix-path.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A tiny, node-free POSIX `path` — the browser-safe substitute for `node:path`
+ * inside the in-browser audit engine (`scan-core.ts` / `scan-files.ts` /
+ * `test-coverage-files.ts` and the core detectors they reach). A Vite bundle of
+ * that engine must not pull `node:path`, so these are pure string ops.
+ *
+ * The audit engine's file-map keys are always POSIX (`/`-separated), and the
+ * disk-side `scanPlugin` feeds it absolute POSIX roots (`resolve(dir)` on Linux),
+ * so a faithful port of Node's `path.posix` algorithm is byte-identical to
+ * `node:path` for every input the engine passes — which is exactly what the
+ * parity firewall (`scan-files.test.ts`) proves. `resolve` deliberately falls
+ * back to `/` (never `process.cwd()`) so it stays pure and process-free; every
+ * call site passes an absolute first segment, so the fallback is never reached.
+ *
+ * NOTE — the functions below are VERBATIM ports of Node's `lib/path.js` POSIX
+ * implementations (charCode scan, `normalizeString`, `basename`, `relative`).
+ * Their branch depth / cyclomatic complexity is inherent to that battle-tested
+ * algorithm; rewriting it to satisfy the complexity linters would risk a subtle
+ * behavioural divergence from `node:path` (which the disk-vs-browser parity gate
+ * relies on), so the metric rules are disabled for this file only.
+ */
+/** POSIX `path.isAbsolute`. */
+export declare function isAbsolute(path: string): boolean;
+/** POSIX `path.normalize`. */
+export declare function normalize(path: string): string;
+/** POSIX `path.join`. */
+export declare function join(...parts: string[]): string;
+/**
+ * POSIX `path.resolve`. Right-to-left until an absolute segment is found, then
+ * normalize. The `i === -1` fallback is `/` (not `process.cwd()`) so this stays
+ * pure; every engine call site passes an absolute first segment.
+ */
+export declare function resolve(...parts: string[]): string;
+/** POSIX `path.dirname`. */
+export declare function dirname(path: string): string;
+/** POSIX `path.basename` (with an optional `suffix` to strip, like `node:path`). */
+export declare function basename(path: string, suffix?: string): string;
+/** POSIX `path.relative`. */
+export declare function relative(from: string, to: string): string;
+//# sourceMappingURL=posix-path.d.ts.map