vigiles 8.0.0 → 9.1.0

package/dist/adoptability.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyDraftedRefs = verifyDraftedRefs;
+exports.parseDraftJson = parseDraftJson;
+exports.runAdoptabilityTier = runAdoptabilityTier;
+exports.formatAdoptability = formatAdoptability;
+/**
+ * Adoptability preview — "what would vigiles catch in YOUR repo?"
+ *
+ * The audit's adoption front door for a NON-adopter: instead of grading the hygiene
+ * of an already-adopted spec, it shows the concrete bugs a spec WOULD catch today.
+ *
+ * Architecture (research/adoption-gateway-preview.md): **LLM proposes, deterministic
+ * disposes.** A model DRAFTS the verifiable references in an instruction file (high
+ * recall, incl. prose intent a regex can't see — `draftRefs`); the deterministic
+ * cross-reference engine VERIFIES each one (`verifyDraftedRefs`, reusing
+ * `checkLinterRule` + the compile validators). The model never gets to assert a
+ * pass — only the verifier does — so the "M broken right now" number is trustworthy
+ * even though the extraction was probabilistic.
+ *
+ * The verifier + parser + formatter are pure and model-free (fully unit-tested); the
+ * single real model call (`defaultDraft`) is the only v8-ignored seam, injected so
+ * the orchestration is testable without a model.
+ */
+const linters_js_1 = require("./core/linters.js");
+const compile_js_1 = require("./core/compile.js");
+const hash_js_1 = require("./core/hash.js");
+const eval_js_1 = require("./eval.js");
+/** Verify ONE drafted ref against the real repo; null = resolves, else the breakage. */
+function verifyOne(r, basePath) {
+    switch (r.kind) {
+        case "enforce": {
+            const res = (0, linters_js_1.checkLinterRule)(r.ref, basePath);
+            if (!res.exists)
+                return {
+                    ...r,
+                    issue: res.error ?? `linter rule "${r.ref}" does not exist`,
+                };
+            if (res.enabled === "disabled")
+                return { ...r, issue: `rule "${r.ref}" exists but is not enabled` };
+            return null;
+        }
+        case "file": {
+            const e = (0, compile_js_1.validateFileRef)(r.ref, basePath);
+            return e ? { kind: r.kind, ref: r.ref, issue: e.message } : null;
+        }
+        case "cmd": {
+            const e = (0, compile_js_1.validateCommandRef)(r.ref, basePath);
+            return e ? { kind: r.kind, ref: r.ref, issue: e.message } : null;
+        }
+        case "dir": {
+            const e = (0, compile_js_1.validateDirRef)(r.ref, basePath);
+            return e ? { kind: r.kind, ref: r.ref, issue: e.message } : null;
+        }
+        default:
+            return (0, hash_js_1.assertNever)(r.kind);
+    }
+}
+/**
+ * Deterministic verdict over drafted refs — the "disposes" half. Dedupes
+ * (kind+ref), routes each to the real cross-ref/filesystem check, and counts the
+ * broken. Pure: a hallucinated rule resolves to broken, never trusted as a pass.
+ */
+function verifyDraftedRefs(refs, basePath) {
+    const seen = new Set();
+    const unique = [];
+    for (const r of refs) {
+        const key = `${r.kind}:${r.ref}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(r);
+    }
+    const brokenRefs = unique
+        .map((r) => verifyOne(r, basePath))
+        .filter((b) => b !== null);
+    return { total: unique.length, broken: brokenRefs.length, brokenRefs };
+}
+const VALID_KINDS = new Set([
+    "enforce",
+    "file",
+    "cmd",
+    "dir",
+]);
+/**
+ * Tolerant parse of the model's draft output into `DraftedRef[]`. The model is
+ * asked for a bare JSON array, but tolerate prose-wrapped / fenced output by
+ * extracting the outermost `[...]`. Drops any entry with an unknown kind or a
+ * non-string ref (the verifier is the guard, but a malformed shape is just noise).
+ */
+function parseDraftJson(text) {
+    const raw = extractJsonArray(text);
+    if (raw === null)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const out = [];
+    for (const item of parsed) {
+        if (typeof item !== "object" || item === null)
+            continue;
+        const rec = item;
+        const kind = rec.kind;
+        const ref = rec.ref;
+        if (typeof kind === "string" &&
+            VALID_KINDS.has(kind) &&
+            typeof ref === "string" &&
+            ref.trim()) {
+            out.push({ kind: kind, ref: ref.trim() });
+        }
+    }
+    return out;
+}
+/** Pull the outermost `[...]` from a possibly prose/fence-wrapped string. */
+function extractJsonArray(text) {
+    const start = text.indexOf("[");
+    const end = text.lastIndexOf("]");
+    if (start === -1 || end === -1 || end < start)
+        return null;
+    return text.slice(start, end + 1);
+}
+/** The drafting prompt — reuse the strengthen/adopt-spec mapping intent. */
+function draftPrompt(content) {
+    return [
+        "You are evaluating whether a coding-agent instruction file's references can be",
+        "machine-verified. Read the instruction file and identify every reference to a",
+        "CONCRETE, VERIFIABLE artifact:",
+        '- a linter rule (kind "enforce", ref like "eslint/no-console" or',
+        '  "@typescript-eslint/no-floating-promises") — INCLUDING prose intent you can',
+        '  confidently map to a real rule (e.g. "always await promises" ->',
+        '  "@typescript-eslint/no-floating-promises", "no console.log" -> "eslint/no-console").',
+        '- a file path (kind "file", ref like "src/index.ts").',
+        '- an npm script (kind "cmd", ref like "npm run build" or "npm test").',
+        '- a directory (kind "dir", ref like "src/components").',
+        "",
+        'Output ONLY a JSON array of {"kind","ref"} objects — no markdown, no prose. If',
+        "none, output []. Do not invent references that aren't grounded in the text.",
+        "",
+        "Instruction file:",
+        "---",
+        content,
+        "---",
+    ].join("\n");
+}
+/* v8 ignore start — the single real model call; the orchestration is tested with a fake draft. */
+/** The "proposes" half: one model call drafting the verifiable refs from prose. */
+async function defaultDraft(content, opts = {}) {
+    const runner = opts.runner ?? eval_js_1.spawnAgent;
+    const parse = opts.parse ?? eval_js_1.parseClaudeRun;
+    const out = await runner({
+        task: draftPrompt(content),
+        cwd: opts.cwd ?? process.cwd(),
+        model: opts.model ?? "sonnet",
+        tools: [], // the content is inline — no file tools needed (deterministic-ish)
+        hasSettings: false,
+        pluginDir: undefined,
+        timeoutMs: 120000,
+        env: process.env,
+    });
+    return parseDraftJson(parse(out).output);
+}
+/**
+ * Run the preview: draft refs from the instruction file (model), then verify them
+ * (deterministic). The composition root of "LLM proposes, deterministic disposes".
+ */
+async function runAdoptabilityTier(opts) {
+    const draft = opts.draft ?? ((c) => defaultDraft(c));
+    const refs = await draft(opts.instructionContent);
+    return verifyDraftedRefs(refs, opts.basePath);
+}
+/** Terminal section — the adoption invitation, not a graded ring. */
+function formatAdoptability(r, instructionFile) {
+    const lines = ["Adoptability — what vigiles would lock in"];
+    if (r.total === 0) {
+        lines.push(`  no machine-verifiable references found in ${instructionFile}.`);
+        return lines.join("\n");
+    }
+    lines.push(`  vigiles drafted a spec from ${instructionFile}: ${String(r.total)} verifiable reference(s) found`);
+    if (r.broken === 0) {
+        lines.push("  ✓ all resolve right now — adopt a spec to keep it that way.");
+        return lines.join("\n");
+    }
+    lines.push(`  ${String(r.broken)} broken right now:`);
+    for (const b of r.brokenRefs) {
+        lines.push(`    ✗ ${b.issue}`);
+    }
+    lines.push("  → run `vigiles init` to adopt the spec and catch these at edit time.");
+    return lines.join("\n");
+}
+//# sourceMappingURL=adoptability.js.map

package/dist/audit-html.d.ts

@@ -0,0 +1,20 @@
+import type { AuditReport } from "./audit-report.js";
+/**
+ * Candidate locations for the built template, relative to this module (`__dirname`
+ * is the compiled `dist/` at runtime, or `src/` under vitest). CommonJS output, so
+ * we use `__dirname`, not `import.meta`.
+ */
+export declare function templatePath(): string | null;
+/**
+ * Inject the report JSON into a template by replacing the quoted placeholder
+ * string with the JSON object literal. Pure — the testable core. Throws if the
+ * template is missing the placeholder.
+ */
+export declare function injectReportData(template: string, report: AuditReport): string;
+/**
+ * Render the self-contained HTML report (React template + injected data). Throws
+ * if the template hasn't been built — the caller (writeAuditHtml) catches that and
+ * skips the HTML, since the JSON + terminal report don't depend on it.
+ */
+export declare function renderAuditHtml(report: AuditReport): string;
+//# sourceMappingURL=audit-html.d.ts.map

package/dist/audit-html.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templatePath = templatePath;
+exports.injectReportData = injectReportData;
+exports.renderAuditHtml = renderAuditHtml;
+/**
+ * The shareable HTML audit report — the prebuilt **Vite + React + shadcn** template
+ * (`report/`, built to one self-contained file at `dist/audit-report.template.html`)
+ * with the {@link AuditReport} JSON injected. The React app runs in the reader's
+ * browser, so the CLI stays runtime-dependency-light and the output is still a
+ * single offline file. There is ONE renderer (pure shadcn/Tailwind) — no inline-CSS
+ * fallback; the build guarantees the template exists, and if it somehow doesn't the
+ * caller skips the HTML (the JSON + terminal report still work).
+ *
+ * `<`/`>`/`&` are escaped on injection so report text can never break out of the
+ * `<script>`. `injectReportData` is the pure, testable core.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const PLACEHOLDER = "__VIGILES_DATA_PLACEHOLDER__";
+/**
+ * Candidate locations for the built template, relative to this module (`__dirname`
+ * is the compiled `dist/` at runtime, or `src/` under vitest). CommonJS output, so
+ * we use `__dirname`, not `import.meta`.
+ */
+function templatePath() {
+    const candidates = [
+        (0, node_path_1.resolve)(__dirname, "audit-report.template.html"), // dist/ (shipped)
+        (0, node_path_1.resolve)(__dirname, "..", "dist", "audit-report.template.html"), // src/ under vitest
+    ];
+    return candidates.find((p) => (0, node_fs_1.existsSync)(p)) ?? null;
+}
+/** Escape `<`, `>`, `&` so report text can never break out of the `<script>`. */
+function escapeForScript(json) {
+    return json.replace(/[<>&]/g, (ch) => "\\u00" + ch.charCodeAt(0).toString(16).padStart(2, "0"));
+}
+/**
+ * Inject the report JSON into a template by replacing the quoted placeholder
+ * string with the JSON object literal. Pure — the testable core. Throws if the
+ * template is missing the placeholder.
+ */
+function injectReportData(template, report) {
+    const re = new RegExp(`(["'])${PLACEHOLDER}\\1`);
+    if (!re.test(template)) {
+        throw new Error("audit report template is missing the data placeholder");
+    }
+    return template.replace(re, escapeForScript(JSON.stringify(report)));
+}
+/**
+ * Render the self-contained HTML report (React template + injected data). Throws
+ * if the template hasn't been built — the caller (writeAuditHtml) catches that and
+ * skips the HTML, since the JSON + terminal report don't depend on it.
+ */
+function renderAuditHtml(report) {
+    const p = templatePath();
+    if (!p) {
+        throw new Error("audit report template not built — run `npm run build` (builds report/), or use --json / --no-html");
+    }
+    return injectReportData((0, node_fs_1.readFileSync)(p, "utf-8"), report);
+}
+//# sourceMappingURL=audit-html.js.map

package/dist/audit-prompts.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Auto-generated trigger probes for `vigiles audit`'s model trigger tier.
+ *
+ * The trigger-rate eval needs a per-skill prompt set (does the description FIRE?
+ * — recall + precision). Authoring that set by hand was the friction that made
+ * the eval un-wowable. The trigger tier removes it: derive a small, DIVERSE probe
+ * set from each skill's own description — zero setup. `--prompts=<file>` still
+ * overrides for a rigorous, curated benchmark.
+ *
+ * Deterministic by design (no model needed to AUTHOR the probes — the model is
+ * spent RUNNING them). The trick that clears the diversity gate: extract a SHORT
+ * topic from the description (so the shared text stays small relative to the
+ * frame) and wrap it in lexically-distant frames. Measured min pairwise NCD
+ * ~0.27 across short/long descriptions — comfortably above {@link AUTO_MIN_DISTANCE}.
+ */
+import type { TriggerPromptSet } from "./scan-behavioral.js";
+export interface PromptSkill {
+    readonly name: string;
+    readonly description: string;
+}
+/** How many recall probes we generate per skill (each a distinct frame). */
+export declare const AUTO_RECALL_COUNT = 6;
+/**
+ * The diversity floor for AUTO probes — relaxed from the default 0.3 because a
+ * templated-but-varied machine probe legitimately shares a topic phrase (the
+ * generator's measured min is ~0.27). Still well above 0 → genuine copy-paste
+ * is caught; the gate's "vary the phrasing" advice is for hand-authored sets.
+ */
+export declare const AUTO_MIN_DISTANCE = 0.2;
+/**
+ * Extract a short, action-shaped topic from a description: drop boilerplate
+ * lead-ins ("A skill that…", "Use this skill to…"), take the first clause, cap
+ * at 8 words. Capping is load-bearing — a long verbatim topic makes the frames
+ * too similar (NCD collapses below the gate).
+ */
+export declare function topicOf(description: string): string;
+/** Recall probes for one skill: distinct frames around its extracted topic. */
+export declare function recallPrompts(description: string, count?: number): string[];
+/**
+ * Build a {@link TriggerPromptSet} from skill descriptions — zero-setup trigger
+ * probes. Each skill gets `recallPrompts` derived from its description plus the
+ * shared irrelevant bank for precision. Skills with an empty description are
+ * skipped (nothing to derive a topic from).
+ */
+export declare function autoTriggerPrompts(skills: readonly PromptSkill[], count?: number): TriggerPromptSet;
+//# sourceMappingURL=audit-prompts.d.ts.map

package/dist/audit-prompts.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTO_MIN_DISTANCE = exports.AUTO_RECALL_COUNT = void 0;
+exports.topicOf = topicOf;
+exports.recallPrompts = recallPrompts;
+exports.autoTriggerPrompts = autoTriggerPrompts;
+/** How many recall probes we generate per skill (each a distinct frame). */
+exports.AUTO_RECALL_COUNT = 6;
+/**
+ * The diversity floor for AUTO probes — relaxed from the default 0.3 because a
+ * templated-but-varied machine probe legitimately shares a topic phrase (the
+ * generator's measured min is ~0.27). Still well above 0 → genuine copy-paste
+ * is caught; the gate's "vary the phrasing" advice is for hand-authored sets.
+ */
+exports.AUTO_MIN_DISTANCE = 0.2;
+// Lexically-distant frames around a short topic. Order matters: the first N are
+// used, and they're arranged so any prefix stays diverse (verified in the test).
+const RECALL_FRAMES = [
+    (t) => `I need help to ${t} in my project right now.`,
+    (t) => `How do I ${t}? Walk me through the steps.`,
+    (t) => `Please ${t} before I open this pull request.`,
+    (t) => `What's the recommended way to ${t} on a large team?`,
+    (t) => `Can you take a look and ${t} for me?`,
+    (t) => `My task today: ${t} across the whole repo.`,
+    (t) => `Is there a tool that will ${t} automatically?`,
+    (t) => `Give me a checklist to ${t} thoroughly.`,
+];
+// Unrelated requests for the precision arm — varied, clearly off-topic, so a
+// well-scoped skill should NOT fire on them (a too-broad description that hijacks
+// these fails precision). Generic on purpose, distant from any one skill's topic.
+// Count is load-bearing: the auto trigger tier applies the diversity gate's
+// `minPrompts` floor (= AUTO_RECALL_COUNT) to BOTH arms, so the bank must hold at
+// least AUTO_RECALL_COUNT entries or the precision arm fails preflight and every
+// skill reports "unmeasured" instead of running.
+const IRRELEVANT_BANK = [
+    "What's the weather forecast for Tokyo this weekend?",
+    "Summarize the plot of Hamlet in two sentences.",
+    "Convert 100 US dollars to euros at today's rate.",
+    "Recommend a good pasta recipe for dinner tonight.",
+    "Who won the most Olympic gold medals in swimming?",
+    "Explain how photosynthesis works in plants.",
+    "Suggest a weekend hiking trail near Seattle.",
+];
+// Boilerplate lead-in words that carry no topical signal (skill descriptions
+// open with a verb — "Reviews…", "Generate…" — so stripping these from the front
+// never eats the real action). Applied iteratively until a content word remains.
+const LEAD_WORD = /^(a|an|the|this|use|skill|agent|tool|command|helper|that|which|to|for|when|invoked?|invoke|used?|helps?|you|with)\b[\s,:-]*/i;
+/**
+ * Extract a short, action-shaped topic from a description: drop boilerplate
+ * lead-ins ("A skill that…", "Use this skill to…"), take the first clause, cap
+ * at 8 words. Capping is load-bearing — a long verbatim topic makes the frames
+ * too similar (NCD collapses below the gate).
+ */
+function topicOf(description) {
+    let t = description.trim().toLowerCase();
+    let prev = "";
+    while (t !== prev) {
+        prev = t;
+        t = t.replace(LEAD_WORD, "");
+    }
+    const firstClause = t.split(/[.,;:!?]/)[0].trim();
+    const words = firstClause.split(/\s+/).filter(Boolean).slice(0, 8);
+    const topic = words.join(" ");
+    // Fall back to the raw (capped, lowercased) description if stripping left nothing.
+    return (topic || description.trim().toLowerCase().split(/\s+/).slice(0, 8).join(" "));
+}
+/** Recall probes for one skill: distinct frames around its extracted topic. */
+function recallPrompts(description, count = exports.AUTO_RECALL_COUNT) {
+    const topic = topicOf(description);
+    return RECALL_FRAMES.slice(0, count).map((frame) => frame(topic));
+}
+/**
+ * Build a {@link TriggerPromptSet} from skill descriptions — zero-setup trigger
+ * probes. Each skill gets `recallPrompts` derived from its description plus the
+ * shared irrelevant bank for precision. Skills with an empty description are
+ * skipped (nothing to derive a topic from).
+ */
+function autoTriggerPrompts(skills, count = exports.AUTO_RECALL_COUNT) {
+    const set = {};
+    for (const s of skills) {
+        if (!s.description.trim())
+            continue;
+        set[s.name] = {
+            prompts: recallPrompts(s.description, count),
+            irrelevant: [...IRRELEVANT_BANK],
+        };
+    }
+    return set;
+}
+//# sourceMappingURL=audit-prompts.js.map

package/dist/audit-report.d.ts

@@ -0,0 +1,107 @@
+/**
+ * The `AuditReport` — the versioned JSON contract that IS the audit's product
+ * boundary. Everything renders FROM it: the local self-contained HTML report,
+ * `audit --json` for CI, and (later) an upload to a hosted dashboard. Because it's
+ * the wire format between the CLI and anything downstream, it is VERSIONED
+ * (`meta.schemaVersion`) and stable — additive changes only within a version.
+ *
+ * Pure: `buildAuditReport` assembles the report from the same deterministic pieces
+ * the terminal output uses (`auditScore` + `optimize` + the scan inventory) — no
+ * re-detection (one-detector-no-drift), no model, no clock (a `generatedAt`
+ * timestamp is attached by the CLI at write time, never by this pure builder, so
+ * the embedded-in-HTML form stays deterministic).
+ */
+import { type AuditScore } from "./audit-score.js";
+import { type Recommendation } from "./optimize.js";
+import type { AdoptabilityResult } from "./adoptability.js";
+import type { ScanReport } from "./scan.js";
+/** The current schema version. Bump only on a BREAKING change to the shape. */
+export declare const AUDIT_SCHEMA_VERSION = 1;
+export interface AuditReportMeta {
+    /** Wire-format version — consumers gate on this. */
+    readonly schemaVersion: typeof AUDIT_SCHEMA_VERSION;
+    readonly tool: "vigiles";
+    /** The vigiles version that produced the report. */
+    readonly vigilesVersion: string;
+    /** The detected/selected harness (`claude-code`, `codex`, …). */
+    readonly harness: string;
+    /** The audited directory. */
+    readonly dir: string;
+    /** ISO-8601 produced-at stamp — set by the CLI at write time (NOT the pure builder). */
+    readonly generatedAt?: string;
+}
+/** What the harness ships — the "inventory" surface counts. */
+export interface AuditInventory {
+    readonly skills: number;
+    readonly agents: number;
+    readonly hooks: number;
+    readonly commands: number;
+    readonly mcp: boolean;
+    readonly untested: number;
+}
+/**
+ * A surface (skill / subagent / instruction file) that EXISTS but doesn't yet
+ * have a `.spec.ts` — so it can be adopted into a typed spec. The report can't
+ * write files (it's a browser app), so it EMITS the exact CLI command instead.
+ */
+export interface AdoptableSurface {
+    /** The repo-relative path of the surface (e.g. `skills/foo/SKILL.md`). */
+    readonly path: string;
+    /** The exact command that adopts this one surface. */
+    readonly command: string;
+}
+/**
+ * The adoptable-surfaces list + the "create all" command — the data the report's
+ * "Create spec" / "Create all specs" affordances copy to the clipboard. Present
+ * only when there's at least one un-spec'd surface; the CLI computes the surface
+ * paths (the layout-aware `discoverAdoptableSurfaces`) and passes them in, so the
+ * pure builder stays adapter-agnostic.
+ */
+export interface Adoptable {
+    readonly surfaces: readonly AdoptableSurface[];
+    /** The one command that adopts every surface at once. */
+    readonly createAllCommand: string;
+}
+/**
+ * The full audit, as the dashboard / CI / HTML all consume it. Self-describing
+ * and versioned; additive-only within a `schemaVersion`.
+ */
+export interface AuditReport {
+    readonly meta: AuditReportMeta;
+    /** The four deterministic category rings + the weighted overall + grade. */
+    readonly score: AuditScore;
+    /** The deterministic, ranked fixes (the inline recommendations). */
+    readonly recommendations: readonly Recommendation[];
+    readonly inventory: AuditInventory;
+    /**
+     * The adoption preview — "what would vigiles catch in your repo?" Present only
+     * when the model-gated tier ran (behind consent); a deterministic read omits it.
+     * Additive/optional, so the schema version is unchanged.
+     */
+    readonly adoptability?: AdoptabilityResult;
+    /**
+     * The surfaces that exist but aren't spec-managed yet, each with the command
+     * that adopts it, plus a "create all" command. Drives the report's "Create
+     * spec" / "Create all specs" command-emit buttons. Present only when there's
+     * at least one adoptable surface. Additive/optional — schema version unchanged.
+     */
+    readonly adoptable?: Adoptable;
+}
+export interface BuildAuditReportOptions {
+    readonly harness: string;
+    readonly vigilesVersion: string;
+    /**
+     * The repo-relative paths of surfaces that exist but have no `.spec.ts` yet,
+     * computed by the CLI's layout-aware `discoverAdoptableSurfaces` (so the pure
+     * builder stays adapter-agnostic — it only formats the commands). Omit/empty
+     * when there's nothing to adopt.
+     */
+    readonly adoptableSurfaces?: readonly string[];
+}
+/**
+ * Assemble the versioned {@link AuditReport} from a scan report — pure, no clock.
+ * The CLI attaches `meta.generatedAt` when it writes the JSON artifact; the
+ * HTML-embedded form omits it so the rendered file stays deterministic.
+ */
+export declare function buildAuditReport(report: ScanReport, opts: BuildAuditReportOptions): AuditReport;
+//# sourceMappingURL=audit-report.d.ts.map

package/dist/audit-report.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUDIT_SCHEMA_VERSION = void 0;
+exports.buildAuditReport = buildAuditReport;
+/**
+ * The `AuditReport` — the versioned JSON contract that IS the audit's product
+ * boundary. Everything renders FROM it: the local self-contained HTML report,
+ * `audit --json` for CI, and (later) an upload to a hosted dashboard. Because it's
+ * the wire format between the CLI and anything downstream, it is VERSIONED
+ * (`meta.schemaVersion`) and stable — additive changes only within a version.
+ *
+ * Pure: `buildAuditReport` assembles the report from the same deterministic pieces
+ * the terminal output uses (`auditScore` + `optimize` + the scan inventory) — no
+ * re-detection (one-detector-no-drift), no model, no clock (a `generatedAt`
+ * timestamp is attached by the CLI at write time, never by this pure builder, so
+ * the embedded-in-HTML form stays deterministic).
+ */
+const audit_score_js_1 = require("./audit-score.js");
+const optimize_js_1 = require("./optimize.js");
+/** The current schema version. Bump only on a BREAKING change to the shape. */
+exports.AUDIT_SCHEMA_VERSION = 1;
+/** The one command that adopts every un-spec'd surface (bare `init`). */
+const CREATE_ALL_COMMAND = "npx vigiles init";
+/** The command that adopts ONE surface at a given repo-relative path. */
+function adoptCommand(path) {
+    return `npx vigiles init --target=${path}`;
+}
+/**
+ * Build the {@link Adoptable} payload from the layout-aware surface paths — pure,
+ * just formats the per-surface + create-all commands. Returns `undefined` when
+ * there's nothing to adopt (so the field stays absent).
+ */
+function buildAdoptable(surfaces) {
+    if (!surfaces || surfaces.length === 0)
+        return undefined;
+    return {
+        surfaces: surfaces.map((path) => ({ path, command: adoptCommand(path) })),
+        createAllCommand: CREATE_ALL_COMMAND,
+    };
+}
+/**
+ * Assemble the versioned {@link AuditReport} from a scan report — pure, no clock.
+ * The CLI attaches `meta.generatedAt` when it writes the JSON artifact; the
+ * HTML-embedded form omits it so the rendered file stays deterministic.
+ */
+function buildAuditReport(report, opts) {
+    const adoptable = buildAdoptable(opts.adoptableSurfaces);
+    return {
+        meta: {
+            schemaVersion: exports.AUDIT_SCHEMA_VERSION,
+            tool: "vigiles",
+            vigilesVersion: opts.vigilesVersion,
+            harness: opts.harness,
+            dir: report.dir,
+        },
+        score: (0, audit_score_js_1.auditScore)(report),
+        recommendations: (0, optimize_js_1.optimize)(report).recommendations,
+        inventory: {
+            skills: report.skills.length,
+            agents: report.agents.length,
+            // All hooks, file-backed + inline — matches formatScanReport and the
+            // emptiness/scoring count, so a JSON/HTML "What it ships" never reports 0
+            // hooks for an inline-hook-only harness.
+            hooks: report.hooks.length + report.inlineHooks,
+            commands: report.commands,
+            mcp: report.mcp,
+            untested: report.untested,
+        },
+        ...(adoptable ? { adoptable } : {}),
+    };
+}
+//# sourceMappingURL=audit-report.js.map