vigiles 14.6.7 → 14.8.0

package/dist/core/mcp.d.ts

@@ -1,3 +1,7 @@
+import { mcpContractToolMessage } from "./mcp-contract-message.js";
+import type { McpContractToolError, McpContractToolReason } from "./mcp-contract-message.js";
+export { mcpContractToolMessage };
+export type { McpContractToolError, McpContractToolReason };
 export interface McpServerConfig {
     readonly command: string;
     readonly args?: readonly string[];
@@ -43,19 +47,7 @@ export declare function loadMcpServers(cwd: string): Record<string, McpServerCon
  * to an undeclared server, an unreachable server, or a missing tool is an error.
  */
 export declare function verifyMcpRefs(markdown: string, mcpServers: Record<string, McpServerConfig>, timeoutMs?: number): Promise<McpRefError[]>;
-export type McpContractToolReason = "server-unreachable" | "tool-missing";
-export interface McpContractToolError {
-    /** The full `mcp__server__tool` reference (restriction suffix stripped). */
-    readonly tool: string;
-    readonly server: string;
-    /** The tool segment (what's looked up on the server). */
-    readonly toolName: string;
-    readonly reason: McpContractToolReason;
-    readonly suggestions: string[];
-}
 export declare function verifyMcpContractTools(tools: readonly string[], servers: Record<string, McpServerConfig>, dialect: import("./dialect.js").HarnessDialect, timeoutMs?: number): Promise<McpContractToolError[]>;
-/** Human-readable message for a contract-tool error (with "did you mean"). */
-export declare function mcpContractToolMessage(e: McpContractToolError): string;
 /** Human-readable message for an MCP reference error (with "did you mean"). */
 export declare function mcpRefMessage(e: McpRefError): string;
 //# sourceMappingURL=mcp.d.ts.map

package/dist/core/mcp.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpContractToolMessage = void 0;
 exports.listMcpTools = listMcpTools;
 exports.verifyMcpTool = verifyMcpTool;
 exports.parseMcpRefs = parseMcpRefs;
 exports.loadMcpServers = loadMcpServers;
 exports.verifyMcpRefs = verifyMcpRefs;
 exports.verifyMcpContractTools = verifyMcpContractTools;
-exports.mcpContractToolMessage = mcpContractToolMessage;
 exports.mcpRefMessage = mcpRefMessage;
 /**
  * Minimal MCP client over stdio — start a server, do the JSON-RPC handshake, and
@@ -24,6 +24,8 @@ const node_path_1 = require("node:path");
 const refs_js_1 = require("./refs.js");
 const hash_js_1 = require("./hash.js");
 const mcp_tool_js_1 = require("./mcp-tool.js");
+const mcp_contract_message_js_1 = require("./mcp-contract-message.js");
+Object.defineProperty(exports, "mcpContractToolMessage", { enumerable: true, get: function () { return mcp_contract_message_js_1.mcpContractToolMessage; } });
 function dispatch(line, pending) {
     let msg;
     try {
@@ -283,19 +285,6 @@ async function verifyMcpContractTools(tools, servers, dialect, timeoutMs = 10000
     }
     return errors;
 }
-/** Human-readable message for a contract-tool error (with "did you mean"). */
-function mcpContractToolMessage(e) {
-    switch (e.reason) {
-        case "server-unreachable":
-            return `MCP tool "${e.tool}" — server "${e.server}" failed to start`;
-        case "tool-missing":
-            return `MCP tool "${e.tool}" not found on server "${e.server}"${e.suggestions.length > 0
-                ? ` — did you mean ${e.suggestions.map((s) => `"${s}"`).join(", ")}?`
-                : ""}`;
-        default:
-            return (0, hash_js_1.assertNever)(e.reason);
-    }
-}
 /** Human-readable message for an MCP reference error (with "did you mean"). */
 function mcpRefMessage(e) {
     switch (e.reason) {

package/dist/core/ncd.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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;
+//# sourceMappingURL=ncd.d.ts.map

package/dist/core/ncd.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ncd = ncd;
+/**
+ * Normalized Compression Distance (NCD) — the model-free similarity engine.
+ *
+ * Extracted from proofs.ts as a NODE-FREE leaf: it depends only on `gzipSync`
+ * (aliased to `pako` in the browser build) and `TextEncoder` (a Web/Node global),
+ * so the description-overlap detector can reach it WITHOUT dragging proofs.ts's
+ * `node:crypto` (hash.js) import into the in-browser audit bundle. proofs.ts
+ * re-exports `ncd` for its existing consumers; the detector imports it from here.
+ *
+ * `TextEncoder` (not `Buffer.from`) keeps the byte input identical across Node and
+ * the browser and removes the node-only `Buffer` global — utf-8 bytes are the same
+ * either way, so gzip sees identical input and the compressed length matches.
+ */
+const node_zlib_1 = require("node:zlib");
+const utf8 = new TextEncoder();
+/**
+ * Compressed size of a string via gzip — approximates Kolmogorov complexity
+ * (the length of the shortest program that produces the string).
+ */
+function compressedSize(s) {
+    return (0, node_zlib_1.gzipSync)(utf8.encode(s), { 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;
+}
+//# sourceMappingURL=ncd.js.map

package/dist/core/plugin-dir-layout.d.ts

@@ -6,13 +6,13 @@ export interface PluginLayoutFinding {
     readonly message: string;
 }
 export interface PluginLayoutOptions {
-    /** Injectable: does this path exist? (default: node:fs existsSync) */
-    readonly existsSync?: (p: string) => boolean;
+    /** REQUIRED, injected: does this path exist? (disk: node:fs existsSync) */
+    readonly existsSync: (p: string) => boolean;
     /**
-     * Injectable: is this path a directory? (default: node:fs
+     * REQUIRED, injected: is this path a directory? (disk: node:fs
      * statSync(p).isDirectory(), returning false on any throw)
      */
-    readonly isDirectory?: (p: string) => boolean;
+    readonly isDirectory: (p: string) => boolean;
 }
 /**
  * Surface directories found nested INSIDE the manifest directory, where they are
@@ -26,5 +26,5 @@ export interface PluginLayoutOptions {
  * Returns `[]` when the manifest dir doesn't exist or holds no misplaced surface
  * dirs.
  */
-export declare function pluginDirLayoutIssues(manifestDir: string, surfaceDirNames: readonly string[], opts?: PluginLayoutOptions): PluginLayoutFinding[];
+export declare function pluginDirLayoutIssues(manifestDir: string, surfaceDirNames: readonly string[], opts: PluginLayoutOptions): PluginLayoutFinding[];
 //# sourceMappingURL=plugin-dir-layout.d.ts.map

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/core/tool-contract.js

@@ -4,7 +4,7 @@ exports.closestTool = closestTool;
 exports.confidentToolIssues = confidentToolIssues;
 exports.disallowedToolIssues = disallowedToolIssues;
 exports.verifyToolContract = verifyToolContract;
-const linters_js_1 = require("./linters.js");
+const edit_distance_js_1 = require("./edit-distance.js");
 /**
  * Closest known built-in tool by edit distance (≤ 2), for a "did you mean" hint.
  * The ≤ 2 bound is deliberately tight: a suggestion is a CONFIDENCE signal (this
@@ -15,7 +15,7 @@ function closestTool(tool, dialect) {
     let best = null;
     let bestDistance = Infinity;
     for (const known of dialect.builtinAgentTools) {
-        const d = (0, linters_js_1.editDistance)(tool.toLowerCase(), known.toLowerCase());
+        const d = (0, edit_distance_js_1.editDistance)(tool.toLowerCase(), known.toLowerCase());
         if (d < bestDistance) {
             bestDistance = d;
             best = known;

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. */