vigiles 28.0.0 → 29.0.0

package/dist/setup-plan.d.ts

@@ -133,7 +133,8 @@ export declare const WORKFLOW_RULES: readonly ["require-instructions-spec", "unt
  */
 export declare const NUDGE_RULES: readonly ["skill-description-budget", "frontmatter-valid", "skill-frontmatter", "prefer-compiled-hooks", "unmarked-refs", "lethal-trifecta", "skill-resource-resolves", "skill-missing-fence", "plugin-dir-layout", "delegation-trifecta", "hook-block-ineffective", "hook-matcher", "doc-refs"];
 export declare function mergeProjectConfig(existing: Record<string, unknown>, opts: {
-    harness: string | string[];
+    /** Canonical harness names this repo targets, in the order to declare them. */
+    harnesses: readonly string[];
     strict: boolean;
     reportOnly?: boolean;
     /** Whether the LINT pillar is on (default true). The rule gate is a lint-layer

package/dist/setup-plan.js

@@ -148,8 +148,13 @@ exports.NUDGE_RULES = [
 function mergeProjectConfig(existing, opts) {
     const config = { ...existing };
     let changed = false;
-    if (config.harness === undefined) {
-        config.harness = opts.harness;
+    // The NESTED key (#240). `init` writes the declaration with no roots — a repo
+    // whose surfaces sit where its harness reads them needs none, and a root is a
+    // fact only the owner knows. Writing the flat `harness`/`surfaceRoots` pair
+    // here would emit a config the loader now REFUSES, which is why this one line
+    // moved with the shape even though the rest of `init` did not.
+    if (config.harnesses === undefined) {
+        config.harnesses = Object.fromEntries(opts.harnesses.map((h) => [h, {}]));
         changed = true;
     }
     // The rule gate belongs to the LINT layer — a test-only setup records the

package/dist/surface-discovery-fs.d.ts

@@ -0,0 +1,12 @@
+import { type DiscoveredSurface } from "./core/surface-discovery.js";
+import { type ExcludeSet } from "./exclude.js";
+/**
+ * Repo-relative paths of every file inside the bounded root set's surface dirs.
+ *
+ * Exported for the test that proves the bound holds — a caller that wants
+ * surfaces wants {@link discoverSurfacesOnDisk}.
+ */
+export declare function boundedSurfacePaths(root: string, excludes?: ExcludeSet): readonly string[];
+/** Every surface the bounded walk finds on disk under `root`, by shape. */
+export declare function discoverSurfacesOnDisk(root: string, excludes?: ExcludeSet): readonly DiscoveredSurface[];
+//# sourceMappingURL=surface-discovery-fs.d.ts.map

package/dist/surface-discovery-fs.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boundedSurfacePaths = boundedSurfacePaths;
+exports.discoverSurfacesOnDisk = discoverSurfacesOnDisk;
+/**
+ * The DISK half of surface discovery: enumerate the repo-relative paths inside
+ * the bounded root set, so the pure classifier in `src/core/surface-discovery.ts`
+ * can say which of them are surfaces.
+ *
+ * Paths only — never contents. Discovery answers "is there a surface here that
+ * nobody reads", which is a question about NAMES; reading a file nobody claims
+ * would be doing the very work the finding says is not being done.
+ *
+ * 🔴 THE WALK IS BOUNDED BY CONSTRUCTION, NOT BY A DEPTH COUNTER. One `readdir`
+ * of the repo root, one per DOT-DIRECTORY found there, and then descent ONLY
+ * into a directory named by `SURFACE_SHAPES` (`skills`/`agents`/`commands`).
+ * `src/`, `packages/`, `node_modules/` are never entered — there is no traversal
+ * that could reach them, so there is no budget to tune and no flag to get wrong.
+ * The module header of `core/surface-discovery.ts` holds the reason the bound is
+ * this shape and why an adapter may not widen it.
+ *
+ * `exclude` is applied PER ENTRY, not only at the entry point, for the reason
+ * b751471 measured: a vendored tree is normally excluded at its own root
+ * (`skills/vendored`), which is a DESCENDANT of a surface dir, so an
+ * entry-point-only check lets every one of its files through. Without this, a
+ * discovery pass that walks dot-directories would grade copied-in corpora as the
+ * repo's own work and the repo's only stated remedy would not reach it.
+ *
+ * Symlinks go through the ONE policy (`src/fs-walk.ts`): `walkableRoot` at each
+ * surface dir the layout-blind walk opens, `entryOf` for every entry below it.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const surface_discovery_js_1 = require("./core/surface-discovery.js");
+const exclude_js_1 = require("./exclude.js");
+const fs_walk_js_1 = require("./fs-walk.js");
+/** The shape directory names, as a set — the only dirs the walk descends into. */
+const SHAPE_DIRS = new Set(surface_discovery_js_1.SURFACE_SHAPES.map((s) => s.dir));
+/** Directory entry names under `dir`, or `[]` when it cannot be read. */
+function namesIn(dir) {
+    try {
+        return (0, node_fs_1.readdirSync)(dir);
+    }
+    catch {
+        return []; // unreadable: the same silence `entryOf` gives, never a throw
+    }
+}
+/** Every file path (repo-relative, POSIX) under an opened surface directory. */
+function filesUnder(root, rel, excluded, out) {
+    const abs = (0, node_path_1.join)(root, rel);
+    for (const name of namesIn(abs)) {
+        const childRel = `${rel}/${name}`;
+        const childAbs = (0, node_path_1.join)(root, childRel);
+        if (excluded(childAbs))
+            continue;
+        const entry = (0, fs_walk_js_1.entryOf)(childAbs);
+        if (entry.kind === "dir")
+            filesUnder(root, childRel, excluded, out);
+        // `childRel` is built with `/` from `readdir` names (which never contain a
+        // separator), so it is already the POSIX form the classifier matches on.
+        else if (entry.kind === "file")
+            out.push(childRel);
+    }
+}
+/**
+ * Repo-relative paths of every file inside the bounded root set's surface dirs.
+ *
+ * Exported for the test that proves the bound holds — a caller that wants
+ * surfaces wants {@link discoverSurfacesOnDisk}.
+ */
+function boundedSurfacePaths(root, excludes) {
+    const excluded = (0, exclude_js_1.excludedBy)(excludes);
+    const out = [];
+    // The repo root is a discovery root, and so is each of its dot-directories.
+    const roots = ["", ...namesIn(root).filter((n) => (0, surface_discovery_js_1.isDiscoveryRoot)(n))];
+    for (const base of roots.filter((b) => b === "" || !excluded((0, node_path_1.join)(root, b)))) {
+        for (const rel of surfaceDirsIn(root, base)) {
+            if (openableSurfaceDir(root, rel, excluded))
+                filesUnder(root, rel, excluded, out);
+        }
+    }
+    return out;
+}
+/** Repo-relative surface dirs directly under one discovery root. */
+function surfaceDirsIn(root, base) {
+    const baseAbs = base === "" ? root : (0, node_path_1.join)(root, base);
+    return namesIn(baseAbs)
+        .filter((n) => SHAPE_DIRS.has(n))
+        .map((n) => (base === "" ? n : `${base}/${n}`));
+}
+/** May the walk open `<root>/<rel>` as a surface directory? */
+function openableSurfaceDir(root, rel, excluded) {
+    const abs = (0, node_path_1.join)(root, rel);
+    if (excluded(abs))
+        return false;
+    // A FILE named `skills` is not a surface dir. A SYMLINKED one is (`entryOf`
+    // says "skip" for it, deliberately — that rule is for entries the walk finds
+    // INSIDE), so the entry point gets `walkableRoot`, which follows it unless
+    // the target contains the scanned root. See src/fs-walk.ts.
+    if ((0, fs_walk_js_1.entryOf)(abs).kind === "file")
+        return false;
+    return (0, fs_walk_js_1.walkableRoot)(abs, root);
+}
+/** Every surface the bounded walk finds on disk under `root`, by shape. */
+function discoverSurfacesOnDisk(root, excludes) {
+    return (0, surface_discovery_js_1.discoverSurfaces)(boundedSurfacePaths(root, excludes));
+}
+//# sourceMappingURL=surface-discovery-fs.js.map