vigiles 32.0.1 → 32.1.0

package/dist/adapters/claude-code/instruction-chain.js

@@ -239,7 +239,17 @@ function excludesIn(text, parse) {
 /** Does this rule file declare a `paths:` scope — i.e. load only on demand? */
 function isPathScoped(text) {
     const { data } = (0, frontmatter_read_js_1.readFrontmatter)(text);
-    return data !== null && Object.hasOwn(data, PATH_SCOPE_KEY);
+    if (data === null || !Object.hasOwn(data, PATH_SCOPE_KEY))
+        return false;
+    // A SCOPE IS A NON-EMPTY LIST OF GLOBS, not the presence of the key.
+    // `paths: []` names no file to load on and a scalar is not the documented
+    // shape; reading either as on-demand would let one frontmatter line drop a
+    // rule's whole size from the always-loaded total — an under-report, the
+    // direction that reads as "you are fine". So both count as always-loaded.
+    const value = data[PATH_SCOPE_KEY];
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((g) => typeof g === "string"));
 }
 /**
  * `CLAUDE.md` → `CLAUDE.local.md`: the per-machine sibling, DERIVED so the two
@@ -452,6 +462,21 @@ function supersederOf(files, input, isExcluded) {
     // keeps another.
     return candidates.find((c) => files[c.path] !== undefined && !isExcluded(c.path));
 }
+/** One loaded file's `@import` tokens, reported only — never taken. */
+function nameImportsOf(b, entry) {
+    const text = b.files[entry.path];
+    if (text === undefined)
+        return;
+    const named = importTokens(text)
+        .filter((token) => (0, instruction_chain_js_1.isRepoRootedImport)(token.slice(1)))
+        .map((token) => ({
+        path: (0, instruction_chain_js_1.resolveImportPath)(entry.path, token.slice(1)),
+        token,
+        from: entry.path,
+    }))
+        .filter((n) => !b.imports.some((m) => m.path === n.path && m.from === n.from));
+    b.imports.push(...named);
+}
 /** One loaded file's `@import` tokens: reported, and TAKEN when already present. */
 function takeImportsOf(b, entry) {
     const text = b.files[entry.path];
@@ -561,8 +586,17 @@ function claudeCodeInstructionChain(files, input) {
     // assumed — `instruction-chain.test.ts` runs each against an `AGENTS.md` that
     // got in as a ROOT file, since a role-keyed version of either would pass every
     // `CLAUDE.md` case and fail exactly those two.
-    for (const entry of [...b.loaded])
+    const firstHop = [...b.loaded];
+    for (const entry of firstHop)
         takeImportsOf(b, entry);
+    // THE SECOND HOP IS NAMED, NEVER TAKEN. One level is what this reads (the
+    // corpus measurement is on `resolveImports`), but the vendor follows up to
+    // four, so an imported file's own tokens are real weight this number lacks.
+    // Recording them as imports — not loading them — lets the weight list them
+    // as unread instead of silently dropping them.
+    for (const entry of b.loaded.filter((e) => !firstHop.includes(e))) {
+        nameImportsOf(b, entry);
+    }
     // THE SUBDIRECTORY PASS, AFTER THE IMPORTS AND NOT BEFORE THEM. Order is the
     // whole of a fixed bug: this pass claims ANY slash path whose leaf is an
     // instruction name, and `takeImportsOf` skips a path already `known`. Running

package/dist/cli-flag-check.js

@@ -78,7 +78,13 @@ exports.COMMAND_FLAGS = {
     ],
     compile: [],
     eject: ["--keep-spec"],
-    lint: ["--bundles=", "--summary", "--json", "--json-out="],
+    lint: [
+        "--bundles=",
+        "--summary",
+        "--json",
+        "--json-out=",
+        "--update-baseline",
+    ],
     // handleRunScripts (free tier — no lock flags).
     test: ["--min=", "--all", "--yes", "--no-interactive", "--no-skip"],
     // handleRunScripts + resolveEvalLockEnv + the trials knob.

package/dist/cli-main.d.ts

@@ -77,6 +77,8 @@ interface LintReport {
     hookBlockErrors: number;
     hookMatcherIssues: number;
     hookMatcherErrors: number;
+    instructionWeightIssues: number;
+    instructionWeightErrors: number;
     docRefErrors: number;
     symbolRefErrors: number;
     mcpRefErrors: number;

package/dist/cli-main.js

@@ -34,6 +34,7 @@ const setup_plan_js_1 = require("./setup-plan.js");
 const types_js_1 = require("./core/types.js");
 const test_coverage_js_1 = require("./test-coverage.js");
 const scan_js_1 = require("./scan.js");
+const instruction_weight_ratchet_js_1 = require("./instruction-weight-ratchet.js");
 const frame_js_1 = require("./core/frame.js");
 const surface_discovery_js_1 = require("./core/surface-discovery.js");
 const scan_trigger_suggest_js_1 = require("./scan-trigger-suggest.js");
@@ -978,6 +979,7 @@ function lintExitCode(report) {
         report.delegationTrifectaErrors > 0 ||
         report.hookBlockErrors > 0 ||
         report.hookMatcherErrors > 0 ||
+        report.instructionWeightErrors > 0 ||
         report.symbolRefErrors > 0 ||
         report.mcpRefErrors > 0 ||
         // `doc-refs` is opt-in and this counter is only non-zero when the user set
@@ -1675,6 +1677,22 @@ async function runLint(restArgs, flags, excludes, config) {
     // typo, an uncompilable or unreachable MCP pattern, one too narrow for real
     // server naming, or an undeclared MCP server).
     const hookMatcher = overBundles(checkHookMatcher, run, lintRoots);
+    // 7v. Instruction-weight ratchet — the always-loaded instruction weight may
+    // not move off the committed baseline. One file for the whole run (bundles
+    // are keys inside it), so it runs ONCE over `lintRoots`, not per bundle.
+    const instructionWeight = (0, instruction_weight_ratchet_js_1.checkInstructionWeightRatchet)({
+        root: frame.root,
+        severity: (0, types_js_1.ruleSeverity)(config?.rules?.["instruction-weight"]),
+        update: flags.includes("--update-baseline"),
+        silent,
+        measure: () => lintRoots.map((abs) => [
+            frame.bundle(abs).at,
+            (0, scan_js_1.measureInstructionWeight)(abs, adapter),
+        ]),
+        annotate: (level, message) => {
+            ghAnnotate(level, message);
+        },
+    });
     // 8. Validate vigiles builder calls inside markdown code blocks — the
     // `doc-refs` rule, DEFAULT OFF. Illustrative blocks opt out via
     // `<!-- vigiles:ignore -->` (single block) or `<!-- vigiles:ignore-file -->`
@@ -1803,6 +1821,8 @@ async function runLint(restArgs, flags, excludes, config) {
         hookBlockErrors: hookBlock.errors,
         hookMatcherIssues: hookMatcher.issues,
         hookMatcherErrors: hookMatcher.errors,
+        instructionWeightIssues: instructionWeight.issues,
+        instructionWeightErrors: instructionWeight.errors,
         // Only the "error" tier gates. At "warn" the findings are printed and
         // annotated, and the exit code is untouched — same contract as every other
         // opt-in rule here.
@@ -6636,6 +6656,18 @@ async function main() {
             if (specs.length > 0)
                 valid =
                     (await compile(specs, config, excludes, { harnessFlag })) && valid;
+            // The always-loaded weight the author just produced, against the
+            // committed baseline — shown at the moment of change. Report-only:
+            // `lint` is the gate (rule `instruction-weight`).
+            if (specs.length > 0) {
+                const weightLine = (0, instruction_weight_ratchet_js_1.compileWeightLine)(process.cwd(), (0, scan_js_1.measureInstructionWeight)(process.cwd(), (0, adapter_registry_js_1.resolveHarnessSelection)({
+                    root: process.cwd(),
+                    flag: harnessFlag,
+                    configHarness: (0, adapter_registry_js_1.declaredHarnessNames)(config.harnesses),
+                }).adapter));
+                if (weightLine !== null)
+                    console.log(`\n${weightLine}`);
+            }
             valid =
                 (await installHooks(hooks, harnessFlag, (0, adapter_registry_js_1.declaredHarnessNames)(config.harnesses))) && valid;
             // Keep an existing whole-harness registry in sync (cheap, opt-in) so the

package/dist/core/config-schema.d.ts

@@ -131,6 +131,7 @@ export declare const vigilesConfigSchema: z.ZodObject<{
         "hook-block-ineffective": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
         "hook-matcher": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
         "doc-refs": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
+        "instruction-weight": z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodLiteral<"warn">, z.ZodLiteral<"error">, z.ZodLiteral<false>, z.ZodLiteral<"off">, z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<true>]>, z.ZodTransform<false | "warn" | "error", boolean | 0 | 1 | 2 | "warn" | "error" | "off">>>;
     }, z.core.$strict>>;
     files: z.ZodDefault<z.ZodArray<z.ZodString>>;
     maxRules: z.ZodOptional<z.ZodNumber>;

package/dist/core/config-schema.js

@@ -163,6 +163,7 @@ const rulesSchema = zod_1.z
     "hook-block-ineffective": severitySchema.default("warn"),
     "hook-matcher": severitySchema.default("warn"),
     "doc-refs": severitySchema.default(false),
+    "instruction-weight": severitySchema.default("error"),
 })
     .strict();
 /** The rule names, for the "did you mean" on an unknown one. */

package/dist/core/instruction-baseline.d.ts

@@ -0,0 +1,139 @@
+/**
+ * The instruction-weight RATCHET: the always-loaded weight may not grow past
+ * what the repository itself last recorded.
+ *
+ * WHY A RATCHET AND NOT THE BUDGET. `./instruction-weight.ts` explains why the
+ * harness's own threshold cannot gate: real repositories sit several times over
+ * it, and a rule that fails every repo on day one is switched off on day one.
+ * What CAN gate is the repository's own past. The baseline is whatever the repo
+ * weighed when it was last recorded, so a repo four times over budget starts
+ * green — and stays green only while it does not get heavier. The measured case
+ * this exists for: a root instruction file cut from ~4 100 lines to ~1 900, then
+ * regrown by ~1 000 lines over ten ordinary commits, with nothing in CI to say so.
+ *
+ * WHY THE SUM, AGAIN. The baseline records `committedTotal`, the same number the
+ * audit report scores: everything the harness loads without being asked that a
+ * teammate on the same commit also loads. A per-file baseline would read text
+ * moved into an always-loaded sibling as a shrink — the evasion the weight
+ * module was built to see through. The per-file sizes are recorded too, but only
+ * so a message can say WHICH file moved; the verdict is decided on the total.
+ *
+ * WHY A SHRINK IS A FINDING TOO. A baseline left above the tree is headroom, and
+ * headroom is exactly where the regrowth above landed: every character up to the
+ * old number would pass. So, like ESLint's unpruned suppressions and `betterer
+ * ci`, a tree LIGHTER than its baseline asks for the baseline to be lowered —
+ * one command, in the same change that made the cut. The baseline then always
+ * equals the tree on the default branch, and any growth at all is a diff a
+ * reviewer sees.
+ *
+ * WHO WRITES IT. Never `lint` on its own: a read never writes. The file is
+ * written only by the explicit `vigiles lint --update-baseline`, the same shape
+ * as `eslint --suppress-all` / `--prune-suppressions` and `jest -u`. Raising the
+ * baseline is allowed and is the point: growth is not forbidden, it is made
+ * visible as a reviewed diff of a committed file.
+ *
+ * Pure: parsing, comparison and formatting only. Reading and writing the file
+ * is the caller's (`src/instruction-weight-ratchet.ts`).
+ */
+import { z } from "zod";
+import type { InstructionWeight } from "./instruction-weight.js";
+/** Where the baseline lives, relative to the directory `.vigilesrc.json` is read from. */
+export declare const INSTRUCTION_BASELINE_FILE = ".vigiles/instruction-weight.json";
+/** The command that writes the baseline — named once, quoted by every message. */
+export declare const UPDATE_BASELINE_COMMAND = "vigiles lint --update-baseline";
+/** Bumped only on an incompatible change to the on-disk shape. */
+export declare const INSTRUCTION_BASELINE_VERSION = 1;
+/**
+ * Which MEASUREMENT produced a recorded number — bumped whenever a release
+ * changes what counts (chain membership in any adapter, how a file is sized),
+ * even when the file shape stays the same.
+ *
+ * Without it, a vigiles fix that moves a file into or out of the chain moves
+ * `committedTotal` on every consumer with a committed baseline, and they see
+ * `grew`/`shrank` attributed to their own content. With it, they see one
+ * "re-record" verdict that names the cause. `version` cannot do this job: it
+ * describes the file, not the number in it.
+ */
+export declare const INSTRUCTION_WEIGHT_MEASURE = 1;
+declare const entrySchema: z.ZodObject<{
+    unit: z.ZodEnum<{
+        chars: "chars";
+        bytes: "bytes";
+    }>;
+    measure: z.ZodNumber;
+    total: z.ZodNumber;
+    files: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strict>;
+declare const baselineSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    bundles: z.ZodRecord<z.ZodString, z.ZodObject<{
+        unit: z.ZodEnum<{
+            chars: "chars";
+            bytes: "bytes";
+        }>;
+        measure: z.ZodNumber;
+        total: z.ZodNumber;
+        files: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** One bundle's recorded weight. */
+export type BaselineEntry = z.infer<typeof entrySchema>;
+/** The whole committed file. */
+export type InstructionBaseline = z.infer<typeof baselineSchema>;
+/** The file's contents, parsed once at the boundary. */
+export type ParsedBaseline = {
+    readonly kind: "ok";
+    readonly baseline: InstructionBaseline;
+} | {
+    readonly kind: "invalid";
+    readonly message: string;
+};
+export declare function parseInstructionBaseline(text: string): ParsedBaseline;
+/** What a measured weight would be recorded as: the SCORED files only. */
+export declare function entryFor(weight: InstructionWeight): BaselineEntry;
+/** One file whose recorded size differs. `null` = absent on that side. */
+export interface FileChange {
+    readonly path: string;
+    readonly from: number | null;
+    readonly to: number | null;
+}
+/**
+ * The comparison of a tree against its baseline. Each case is a different fact,
+ * so each is its own member — "no baseline" is not "equal", and a baseline in
+ * another unit is not a number to subtract.
+ */
+export type RatchetVerdict = {
+    readonly kind: "unrecorded";
+    /** What `--update-baseline` would write. */
+    readonly current: BaselineEntry;
+} | {
+    readonly kind: "unit-changed";
+    readonly recorded: BaselineEntry["unit"];
+    readonly current: BaselineEntry["unit"];
+} | {
+    readonly kind: "measure-changed";
+    readonly recorded: number;
+    readonly current: number;
+} | {
+    readonly kind: "held";
+    readonly total: number;
+    readonly unit: BaselineEntry["unit"];
+} | {
+    readonly kind: "grew" | "shrank";
+    readonly from: number;
+    readonly to: number;
+    readonly unit: BaselineEntry["unit"];
+    /** Every file whose size moved, largest movement first. */
+    readonly changes: readonly FileChange[];
+};
+export declare function compareToBaseline(weight: InstructionWeight, recorded: BaselineEntry | undefined): RatchetVerdict;
+/** Replace the measured bundles' entries; `null` removes one. Others are kept. */
+export declare function recordEntries(previous: InstructionBaseline | undefined, measured: readonly (readonly [string, BaselineEntry | null])[]): InstructionBaseline;
+/** Stable text: sorted keys, two-space indent, trailing newline, no timestamp. */
+export declare function serializeBaseline(baseline: InstructionBaseline): string;
+/** The one-paragraph message a verdict prints as, prefixed by its bundle. */
+export declare function formatVerdict(verdict: RatchetVerdict, at: string): string;
+/** The compile-time one-liner: weight now, against the baseline when there is one. */
+export declare function formatWeightLine(verdict: RatchetVerdict): string;
+export {};
+//# sourceMappingURL=instruction-baseline.d.ts.map

package/dist/core/instruction-baseline.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTRUCTION_WEIGHT_MEASURE = exports.INSTRUCTION_BASELINE_VERSION = exports.UPDATE_BASELINE_COMMAND = exports.INSTRUCTION_BASELINE_FILE = void 0;
+exports.parseInstructionBaseline = parseInstructionBaseline;
+exports.entryFor = entryFor;
+exports.compareToBaseline = compareToBaseline;
+exports.recordEntries = recordEntries;
+exports.serializeBaseline = serializeBaseline;
+exports.formatVerdict = formatVerdict;
+exports.formatWeightLine = formatWeightLine;
+/**
+ * The instruction-weight RATCHET: the always-loaded weight may not grow past
+ * what the repository itself last recorded.
+ *
+ * WHY A RATCHET AND NOT THE BUDGET. `./instruction-weight.ts` explains why the
+ * harness's own threshold cannot gate: real repositories sit several times over
+ * it, and a rule that fails every repo on day one is switched off on day one.
+ * What CAN gate is the repository's own past. The baseline is whatever the repo
+ * weighed when it was last recorded, so a repo four times over budget starts
+ * green — and stays green only while it does not get heavier. The measured case
+ * this exists for: a root instruction file cut from ~4 100 lines to ~1 900, then
+ * regrown by ~1 000 lines over ten ordinary commits, with nothing in CI to say so.
+ *
+ * WHY THE SUM, AGAIN. The baseline records `committedTotal`, the same number the
+ * audit report scores: everything the harness loads without being asked that a
+ * teammate on the same commit also loads. A per-file baseline would read text
+ * moved into an always-loaded sibling as a shrink — the evasion the weight
+ * module was built to see through. The per-file sizes are recorded too, but only
+ * so a message can say WHICH file moved; the verdict is decided on the total.
+ *
+ * WHY A SHRINK IS A FINDING TOO. A baseline left above the tree is headroom, and
+ * headroom is exactly where the regrowth above landed: every character up to the
+ * old number would pass. So, like ESLint's unpruned suppressions and `betterer
+ * ci`, a tree LIGHTER than its baseline asks for the baseline to be lowered —
+ * one command, in the same change that made the cut. The baseline then always
+ * equals the tree on the default branch, and any growth at all is a diff a
+ * reviewer sees.
+ *
+ * WHO WRITES IT. Never `lint` on its own: a read never writes. The file is
+ * written only by the explicit `vigiles lint --update-baseline`, the same shape
+ * as `eslint --suppress-all` / `--prune-suppressions` and `jest -u`. Raising the
+ * baseline is allowed and is the point: growth is not forbidden, it is made
+ * visible as a reviewed diff of a committed file.
+ *
+ * Pure: parsing, comparison and formatting only. Reading and writing the file
+ * is the caller's (`src/instruction-weight-ratchet.ts`).
+ */
+const zod_1 = require("zod");
+/** Where the baseline lives, relative to the directory `.vigilesrc.json` is read from. */
+exports.INSTRUCTION_BASELINE_FILE = ".vigiles/instruction-weight.json";
+/** The command that writes the baseline — named once, quoted by every message. */
+exports.UPDATE_BASELINE_COMMAND = "vigiles lint --update-baseline";
+/** Bumped only on an incompatible change to the on-disk shape. */
+exports.INSTRUCTION_BASELINE_VERSION = 1;
+/**
+ * Which MEASUREMENT produced a recorded number — bumped whenever a release
+ * changes what counts (chain membership in any adapter, how a file is sized),
+ * even when the file shape stays the same.
+ *
+ * Without it, a vigiles fix that moves a file into or out of the chain moves
+ * `committedTotal` on every consumer with a committed baseline, and they see
+ * `grew`/`shrank` attributed to their own content. With it, they see one
+ * "re-record" verdict that names the cause. `version` cannot do this job: it
+ * describes the file, not the number in it.
+ */
+exports.INSTRUCTION_WEIGHT_MEASURE = 1;
+const entrySchema = zod_1.z
+    .object({
+    unit: zod_1.z.enum(["chars", "bytes"]),
+    measure: zod_1.z.number().int().nonnegative(),
+    total: zod_1.z.number().int().nonnegative(),
+    files: zod_1.z.record(zod_1.z.string(), zod_1.z.number().int().nonnegative()),
+})
+    .strict()
+    .refine((e) => Object.values(e.files).reduce((a, b) => a + b, 0) === e.total, {
+    message: "`total` is not the sum of `files` — the file was edited by hand; re-record it",
+});
+const baselineSchema = zod_1.z
+    .object({
+    version: zod_1.z.literal(exports.INSTRUCTION_BASELINE_VERSION),
+    /** Keyed by bundle location from the config root; `.` is the root itself. */
+    bundles: zod_1.z.record(zod_1.z.string(), entrySchema),
+})
+    .strict();
+function parseInstructionBaseline(text) {
+    const json = (() => {
+        try {
+            return { ok: true, value: JSON.parse(text) };
+        }
+        catch {
+            return { ok: false };
+        }
+    })();
+    if (!json.ok)
+        return { kind: "invalid", message: "not valid JSON" };
+    const parsed = baselineSchema.safeParse(json.value);
+    return parsed.success
+        ? { kind: "ok", baseline: parsed.data }
+        : {
+            kind: "invalid",
+            message: parsed.error.issues
+                .map((i) => `${i.path.join(".") || "(top level)"}: ${i.message}`)
+                .join("; "),
+        };
+}
+/** What a measured weight would be recorded as: the SCORED files only. */
+function entryFor(weight) {
+    const scored = weight.files.filter((f) => f.scope === "repo");
+    return {
+        unit: weight.unit,
+        measure: exports.INSTRUCTION_WEIGHT_MEASURE,
+        total: weight.committedTotal,
+        files: Object.fromEntries([...scored]
+            .sort((a, b) => a.path.localeCompare(b.path))
+            .map((f) => [f.path, f.size])),
+    };
+}
+function changesBetween(before, after) {
+    const paths = [...new Set([...Object.keys(before), ...Object.keys(after)])];
+    const size = (m, p) => Object.hasOwn(m, p) ? m[p] : null;
+    return paths
+        .map((path) => ({ path, from: size(before, path), to: size(after, path) }))
+        .filter((c) => c.from !== c.to)
+        .sort((a, b) => Math.abs((b.to ?? 0) - (b.from ?? 0)) -
+        Math.abs((a.to ?? 0) - (a.from ?? 0)) || a.path.localeCompare(b.path));
+}
+function compareToBaseline(weight, recorded) {
+    const current = entryFor(weight);
+    if (recorded === undefined)
+        return { kind: "unrecorded", current };
+    if (recorded.unit !== current.unit) {
+        return {
+            kind: "unit-changed",
+            recorded: recorded.unit,
+            current: current.unit,
+        };
+    }
+    if (recorded.measure !== current.measure) {
+        return {
+            kind: "measure-changed",
+            recorded: recorded.measure,
+            current: current.measure,
+        };
+    }
+    if (current.total === recorded.total) {
+        return { kind: "held", total: current.total, unit: current.unit };
+    }
+    return {
+        kind: current.total > recorded.total ? "grew" : "shrank",
+        from: recorded.total,
+        to: current.total,
+        unit: current.unit,
+        changes: changesBetween(recorded.files, current.files),
+    };
+}
+/** Replace the measured bundles' entries; `null` removes one. Others are kept. */
+function recordEntries(previous, measured) {
+    const removed = new Set(measured.filter(([, e]) => e === null).map(([at]) => at));
+    const kept = Object.entries(previous?.bundles ?? {}).filter(([at]) => !removed.has(at));
+    const fresh = measured.flatMap(([at, e]) => e === null ? [] : [[at, e]]);
+    return {
+        version: exports.INSTRUCTION_BASELINE_VERSION,
+        bundles: Object.fromEntries([...new Map([...kept, ...fresh]).entries()].sort(([a], [b]) => a.localeCompare(b))),
+    };
+}
+/** Stable text: sorted keys, two-space indent, trailing newline, no timestamp. */
+function serializeBaseline(baseline) {
+    return `${JSON.stringify(baseline, null, 2)}\n`;
+}
+const n = (x) => x.toLocaleString("en-US");
+const signed = (x) => (x > 0 ? `+${n(x)}` : n(x));
+function describeChange(c) {
+    if (c.from === null)
+        return `${c.path} +${n(c.to ?? 0)} (new)`;
+    if (c.to === null)
+        return `${c.path} -${n(c.from)} (gone)`;
+    return `${c.path} ${signed(c.to - c.from)}`;
+}
+/** The one-paragraph message a verdict prints as, prefixed by its bundle. */
+function formatVerdict(verdict, at) {
+    const where = at === "." ? "" : `${at}: `;
+    switch (verdict.kind) {
+        case "unrecorded":
+            return (`${where}no instruction-weight baseline recorded (${n(verdict.current.total)} ${verdict.current.unit} always loaded) — ` +
+                `run \`${exports.UPDATE_BASELINE_COMMAND}\` and commit ${exports.INSTRUCTION_BASELINE_FILE} to stop it growing unnoticed`);
+        case "unit-changed":
+            return (`${where}the instruction-weight baseline is in ${verdict.recorded} but this harness counts ${verdict.current} — ` +
+                `re-record it with \`${exports.UPDATE_BASELINE_COMMAND}\``);
+        case "measure-changed":
+            return (`${where}the instruction-weight baseline was recorded by measurement ${String(verdict.recorded)}, this vigiles uses ${String(verdict.current)} — ` +
+                `what counts changed in vigiles, not in your files. Re-record it with \`${exports.UPDATE_BASELINE_COMMAND}\``);
+        case "held":
+            return `${where}always-loaded instructions held at ${n(verdict.total)} ${verdict.unit} (baseline)`;
+        case "grew":
+        case "shrank": {
+            const head = `${n(verdict.from)} → ${n(verdict.to)} ${verdict.unit} (${signed(verdict.to - verdict.from)})`;
+            const moved = verdict.changes.length > 0
+                ? ` Changed: ${verdict.changes.map(describeChange).join(", ")}.`
+                : "";
+            return verdict.kind === "grew"
+                ? `${where}always-loaded instructions grew ${head} over the recorded baseline.${moved} ` +
+                    `If the growth is intended, record it with \`${exports.UPDATE_BASELINE_COMMAND}\` — the diff of ${exports.INSTRUCTION_BASELINE_FILE} is the review.`
+                : `${where}always-loaded instructions shrank ${head}; the baseline still allows the old weight.${moved} ` +
+                    `Lock the cut in with \`${exports.UPDATE_BASELINE_COMMAND}\`, or the headroom can be regrown without a finding.`;
+        }
+    }
+}
+/** The compile-time one-liner: weight now, against the baseline when there is one. */
+function formatWeightLine(verdict) {
+    switch (verdict.kind) {
+        case "unrecorded":
+            return `always-loaded: ${n(verdict.current.total)} ${verdict.current.unit} (no baseline — \`${exports.UPDATE_BASELINE_COMMAND}\`)`;
+        case "unit-changed":
+            return `always-loaded: baseline is in ${verdict.recorded}, this harness counts ${verdict.current}`;
+        case "measure-changed":
+            return `always-loaded: baseline recorded by measurement ${String(verdict.recorded)}, this vigiles uses ${String(verdict.current)} — re-record`;
+        case "held":
+            return `always-loaded: ${n(verdict.total)} ${verdict.unit} (baseline ${n(verdict.total)}, ±0)`;
+        case "grew":
+        case "shrank":
+            return `always-loaded: ${n(verdict.to)} ${verdict.unit} (baseline ${n(verdict.from)}, ${signed(verdict.to - verdict.from)})`;
+    }
+}
+//# sourceMappingURL=instruction-baseline.js.map

package/dist/core/instruction-weight.d.ts

@@ -28,12 +28,13 @@
  * number carries a different severity per harness, so the harness must supply
  * it — hence a port field, not a constant.
  *
- * NOT A GATE, AND THAT IS MEASURED. Both corpora this was built against sit at
- * roughly four times the Claude Code threshold. A rule that fails every real
- * repo on day one is switched off on day one (`lint-rule-calibration`: severity
- * tracks confidence, and a check nobody leaves on catches nothing). So the
- * first consumer is `audit`, as a REPORT. It earns a severity when a corpus
- * exists that it would not immediately fail.
+ * THE BUDGET IS NOT A GATE, AND THAT IS MEASURED. Both corpora this was built
+ * against sit at roughly four times the Claude Code threshold. A rule that
+ * fails every real repo on day one is switched off on day one
+ * (`lint-rule-calibration`: severity tracks confidence, and a check nobody
+ * leaves on catches nothing). So `audit` reports the budget, and what `lint`
+ * gates is the repo's OWN recorded weight (`./instruction-baseline.ts`): green
+ * on day one at any size, red the day it grows.
  */
 import type { InstructionChain, InstructionRole, InstructionScope } from "./instruction-chain.js";
 /** What the harness counts, and what it does when the count is exceeded. */
@@ -147,7 +148,16 @@ export interface InstructionWeight {
         readonly to: readonly string[];
     }[];
 }
-/** Size in the harness's own unit. Bytes and chars differ on any non-ASCII text. */
+/**
+ * Size in the harness's own unit. Bytes and chars differ on any non-ASCII text.
+ *
+ * Line endings are counted as `\n`. A checkout with `core.autocrlf` holds the
+ * same commit with one more character per line, and a number that differs
+ * between two clones of one commit cannot be committed and compared — a
+ * 1 000-line file read +1 000 on Windows with no content change. The harness
+ * may count the CR itself; reproducibility is worth more here than that
+ * fidelity.
+ */
 export declare function sizeIn(text: string, unit: "chars" | "bytes"): number;
 /**
  * Weigh a harness's LOADED chain against its own budget.

package/dist/core/instruction-weight.js

@@ -29,19 +29,30 @@
  * number carries a different severity per harness, so the harness must supply
  * it — hence a port field, not a constant.
  *
- * NOT A GATE, AND THAT IS MEASURED. Both corpora this was built against sit at
- * roughly four times the Claude Code threshold. A rule that fails every real
- * repo on day one is switched off on day one (`lint-rule-calibration`: severity
- * tracks confidence, and a check nobody leaves on catches nothing). So the
- * first consumer is `audit`, as a REPORT. It earns a severity when a corpus
- * exists that it would not immediately fail.
+ * THE BUDGET IS NOT A GATE, AND THAT IS MEASURED. Both corpora this was built
+ * against sit at roughly four times the Claude Code threshold. A rule that
+ * fails every real repo on day one is switched off on day one
+ * (`lint-rule-calibration`: severity tracks confidence, and a check nobody
+ * leaves on catches nothing). So `audit` reports the budget, and what `lint`
+ * gates is the repo's OWN recorded weight (`./instruction-baseline.ts`): green
+ * on day one at any size, red the day it grows.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sizeIn = sizeIn;
 exports.weighInstructions = weighInstructions;
-/** Size in the harness's own unit. Bytes and chars differ on any non-ASCII text. */
+/**
+ * Size in the harness's own unit. Bytes and chars differ on any non-ASCII text.
+ *
+ * Line endings are counted as `\n`. A checkout with `core.autocrlf` holds the
+ * same commit with one more character per line, and a number that differs
+ * between two clones of one commit cannot be committed and compared — a
+ * 1 000-line file read +1 000 on Windows with no content change. The harness
+ * may count the CR itself; reproducibility is worth more here than that
+ * fidelity.
+ */
 function sizeIn(text, unit) {
-    return unit === "chars" ? text.length : Buffer.byteLength(text, "utf8");
+    const lf = text.replaceAll("\r\n", "\n");
+    return unit === "chars" ? lf.length : Buffer.byteLength(lf, "utf8");
 }
 /**
  * Weigh a harness's LOADED chain against its own budget.
@@ -107,10 +118,15 @@ function weighInstructions(chain, files, budget) {
         committedTotal,
         effectiveTotal: sum(weighed.filter((f) => f.notLoadedHere === undefined)),
         overBy: committedTotal > budget.limit ? committedTotal - budget.limit : null,
+        // NOT "absent from the map": a second-hop target can be in the map (the
+        // import pass read it because its importer was also a candidate) and still
+        // not be in the chain, because the second hop is named, never taken. What
+        // makes an import unread is that the chain did not classify its target.
         unreadImports: [
             ...new Set(chain.imports
                 .map((i) => i.path)
-                .filter((path) => files[path] === undefined)),
+                .filter((path) => !chain.loaded.some((e) => e.path === path) &&
+                !chain.unloaded.some((e) => e.path === path))),
         ].sort(),
         unweighedPatterns: [
             ...new Set(chain.patterns.map((p) => p.pattern)),

package/dist/core/rule-meta.js

@@ -210,6 +210,14 @@ exports.RULE_META = {
         summary: "Two model-invocable skills aren't near-identical (wrong one fires).",
         detector: "findDescriptionOverlaps",
     },
+    "instruction-weight": {
+        id: "instruction-weight",
+        bucket: "external-decidable",
+        surface: ["instruction"],
+        defaultSeverity: "error",
+        summary: "The always-loaded instruction weight did not move off its committed baseline.",
+        detector: "compareToBaseline",
+    },
     "skill-description-budget": {
         id: "skill-description-budget",
         bucket: "heuristic-behavioral",

package/dist/core/types.d.ts

@@ -122,6 +122,14 @@ export interface RulesConfig {
      * exited 0 (#173). Default: "error", matching `compile`.
      */
     "spec-refs"?: RuleSeverity;
+    /**
+     * The always-loaded instruction weight may not move away from the committed
+     * baseline in `.vigiles/instruction-weight.json` — a ratchet against the
+     * repo's own past, not a fixed budget. No baseline file → a one-line note,
+     * never a finding, so turning this on fails no repository on day one.
+     * `vigiles lint --update-baseline` records it. Default: "error".
+     */
+    "instruction-weight"?: RuleSeverity;
     /**
      * Near-duplicate rules WITHIN one spec, by NCD similarity — spec bloat, two
      * rules saying the same thing in different words.

package/dist/instruction-weight-ratchet.d.ts

@@ -0,0 +1,53 @@
+import { type InstructionBaseline, type ParsedBaseline } from "./core/instruction-baseline.js";
+import type { InstructionWeight } from "./core/instruction-weight.js";
+import type { RuleSeverity } from "./core/types.js";
+/** The file on disk, read once: absent, parsed, or refused. */
+export type BaselineOnDisk = {
+    readonly kind: "absent";
+} | ParsedBaseline;
+export declare function readInstructionBaseline(root: string): BaselineOnDisk;
+/** One bundle's measurement: where it is, and its weight (`null` = nothing to weigh). */
+export type MeasuredBundle = readonly [
+    at: string,
+    weight: InstructionWeight | null
+];
+/** Write the baseline for every measured bundle; returns what was written. */
+export declare function writeInstructionBaseline(root: string, onDisk: BaselineOnDisk, measured: readonly MeasuredBundle[]): InstructionBaseline;
+/**
+ * One line of lint output. `finding` counts toward the exit code; `ok` is the
+ * baseline holding; `note` is the opt-in nudge on a repo with no baseline.
+ */
+export interface RatchetLine {
+    readonly at: string;
+    readonly status: "finding" | "ok" | "note";
+    readonly text: string;
+}
+/**
+ * Pure: the lines a run prints, given what was measured and what is on disk.
+ *
+ * A bundle with no entry is a nudge while the repo has NO baseline file (it has
+ * not opted in, and a fresh repo must not fail on day one) — but a FINDING once
+ * the file exists: a bundle that appeared after the baseline was recorded is
+ * weight nobody signed off on.
+ */
+export declare function ratchetLines(onDisk: BaselineOnDisk, measured: readonly MeasuredBundle[]): readonly RatchetLine[];
+/** Run the ratchet for `lint`: print, annotate, count. */
+export declare function checkInstructionWeightRatchet(opts: {
+    readonly root: string;
+    readonly severity: RuleSeverity;
+    readonly update: boolean;
+    readonly silent: boolean;
+    /** Called only when the rule is on or an update was asked for. */
+    readonly measure: () => readonly MeasuredBundle[];
+    readonly annotate: (level: "error" | "warning", message: string) => void;
+}): {
+    issues: number;
+    errors: number;
+};
+/**
+ * The line `compile` prints after writing instruction files: the weight NOW,
+ * against the baseline, at the moment the author changed it. Report-only —
+ * `lint` stays the single gate. `null` when there is nothing to weigh.
+ */
+export declare function compileWeightLine(root: string, weight: InstructionWeight | null): string | null;
+//# sourceMappingURL=instruction-weight-ratchet.d.ts.map

package/dist/instruction-weight-ratchet.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readInstructionBaseline = readInstructionBaseline;
+exports.writeInstructionBaseline = writeInstructionBaseline;
+exports.ratchetLines = ratchetLines;
+exports.checkInstructionWeightRatchet = checkInstructionWeightRatchet;
+exports.compileWeightLine = compileWeightLine;
+/**
+ * `lint`'s side of the instruction-weight ratchet: measure each scored bundle,
+ * compare it with `.vigiles/instruction-weight.json`, and — only under the
+ * explicit `--update-baseline` — write that file.
+ *
+ * The decisions (what a verdict is, what it says) live in
+ * `core/instruction-baseline.ts`; this module owns the two effects the core
+ * must not have, reading and writing the committed file, plus turning verdicts
+ * into lint counters.
+ *
+ * WHY THE FILE IS COMMITTED, unlike `.vigiles/coverage.json`. Coverage records
+ * what tests ran on THIS machine, so a committed copy would credit a checkout
+ * where nothing ran. The baseline records a property of the COMMIT: it is built
+ * from `committedTotal`, which already leaves out every per-machine file
+ * (`CLAUDE.local.md`, a gitignored settings sibling), so two clones of one
+ * commit compute byte-identical files. That is what lets CI compare against it.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const instruction_baseline_js_1 = require("./core/instruction-baseline.js");
+function readInstructionBaseline(root) {
+    const path = (0, node_path_1.join)(root, instruction_baseline_js_1.INSTRUCTION_BASELINE_FILE);
+    return (0, node_fs_1.existsSync)(path)
+        ? (0, instruction_baseline_js_1.parseInstructionBaseline)((0, node_fs_1.readFileSync)(path, "utf-8"))
+        : { kind: "absent" };
+}
+/** Write the baseline for every measured bundle; returns what was written. */
+function writeInstructionBaseline(root, onDisk, measured) {
+    const next = (0, instruction_baseline_js_1.recordEntries)(onDisk.kind === "ok" ? onDisk.baseline : undefined, measured.map(([at, w]) => [at, w === null ? null : (0, instruction_baseline_js_1.entryFor)(w)]));
+    const path = (0, node_path_1.join)(root, instruction_baseline_js_1.INSTRUCTION_BASELINE_FILE);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    (0, node_fs_1.writeFileSync)(path, (0, instruction_baseline_js_1.serializeBaseline)(next));
+    return next;
+}
+/**
+ * Pure: the lines a run prints, given what was measured and what is on disk.
+ *
+ * A bundle with no entry is a nudge while the repo has NO baseline file (it has
+ * not opted in, and a fresh repo must not fail on day one) — but a FINDING once
+ * the file exists: a bundle that appeared after the baseline was recorded is
+ * weight nobody signed off on.
+ */
+function ratchetLines(onDisk, measured) {
+    if (onDisk.kind === "invalid") {
+        return [
+            {
+                at: ".",
+                status: "finding",
+                text: `${instruction_baseline_js_1.INSTRUCTION_BASELINE_FILE} cannot be read (${onDisk.message}) — ` +
+                    `re-record it with \`${instruction_baseline_js_1.UPDATE_BASELINE_COMMAND}\``,
+            },
+        ];
+    }
+    const recorded = onDisk.kind === "ok" ? onDisk.baseline.bundles : {};
+    return measured.flatMap(([at, weight]) => {
+        if (weight === null)
+            return [];
+        const verdict = (0, instruction_baseline_js_1.compareToBaseline)(weight, Object.hasOwn(recorded, at) ? recorded[at] : undefined);
+        const status = verdict.kind === "held"
+            ? "ok"
+            : verdict.kind === "unrecorded" && onDisk.kind !== "ok"
+                ? "note"
+                : "finding";
+        // An import named and not read is weight this number lacks — a second
+        // hop, or a path that does not resolve. Said on the line itself, because
+        // the gate holding is only as true as the sum it holds.
+        const unfollowed = weight.unreadImports.length > 0
+            ? ` (${String(weight.unreadImports.length)} import(s) not followed: ${weight.unreadImports.join(", ")} — their size is not in this number)`
+            : "";
+        return [{ at, status, text: `${(0, instruction_baseline_js_1.formatVerdict)(verdict, at)}${unfollowed}` }];
+    });
+}
+/** Run the ratchet for `lint`: print, annotate, count. */
+function checkInstructionWeightRatchet(opts) {
+    const { severity, update, silent } = opts;
+    if (!severity && !update)
+        return { issues: 0, errors: 0 };
+    const measured = opts.measure();
+    const before = readInstructionBaseline(opts.root);
+    const onDisk = update
+        ? {
+            kind: "ok",
+            baseline: writeInstructionBaseline(opts.root, before, measured),
+        }
+        : before;
+    const lines = severity ? ratchetLines(onDisk, measured) : [];
+    const findings = lines.filter((l) => l.status === "finding");
+    if (!silent && (update || lines.length > 0)) {
+        console.log("\nInstruction-weight ratchet:\n");
+        if (update)
+            console.log(`  ✓ recorded ${instruction_baseline_js_1.INSTRUCTION_BASELINE_FILE}`);
+        const marks = {
+            finding: severity === "error" ? "✗" : "⚠",
+            ok: "✓",
+            note: "ℹ",
+        };
+        lines.forEach((l) => {
+            console.log(`  ${marks[l.status]} ${l.text}`);
+        });
+    }
+    const level = severity === "error" ? "error" : "warning";
+    findings.forEach((l) => {
+        opts.annotate(level, l.text);
+    });
+    return {
+        issues: findings.length,
+        errors: severity === "error" ? findings.length : 0,
+    };
+}
+/**
+ * The line `compile` prints after writing instruction files: the weight NOW,
+ * against the baseline, at the moment the author changed it. Report-only —
+ * `lint` stays the single gate. `null` when there is nothing to weigh.
+ */
+function compileWeightLine(root, weight) {
+    if (weight === null)
+        return null;
+    const onDisk = readInstructionBaseline(root);
+    if (onDisk.kind === "invalid") {
+        return `always-loaded: ${instruction_baseline_js_1.INSTRUCTION_BASELINE_FILE} cannot be read (${onDisk.message})`;
+    }
+    const recorded = onDisk.kind === "ok" ? onDisk.baseline.bundles : {};
+    return (0, instruction_baseline_js_1.formatWeightLine)((0, instruction_baseline_js_1.compareToBaseline)(weight, Object.hasOwn(recorded, ".") ? recorded["."] : undefined));
+}
+//# sourceMappingURL=instruction-weight-ratchet.js.map

package/dist/local-files.js

@@ -107,6 +107,7 @@ exports.COMMITTED_PATHS = [
     "schema.json", // YAML-LSP frontmatter schema (`vigiles init`)
     "guards.json", // the declared guard set (`core/guards.ts`)
     "action-gates.json", // declared action gates (`action-gate.ts`)
+    "instruction-weight.json", // the instruction-weight ratchet's baseline (`core/instruction-baseline.ts`)
 ];
 /** The header comment on a `.vigiles/.gitignore` vigiles creates. */
 /** The ignore file vigiles keeps inside `.vigiles/`. One spelling for every reader. */

package/dist/scan.d.ts

@@ -411,6 +411,16 @@ export interface ScanHarness {
     readonly dialect: HarnessDialect;
     readonly roots: readonly string[];
 }
+/**
+ * The always-loaded instruction weight of ONE directory under ONE harness —
+ * the bounded read, the harness's chain, and the sum, in one place.
+ *
+ * `scanPlugin` reports it, `lint`'s instruction-weight ratchet gates on it and
+ * `compile` prints it, so all three must arrive at the same number by the same
+ * route; this function is that route. `null` when the harness publishes no
+ * budget (there is no unit to count in).
+ */
+export declare function measureInstructionWeight(dir: string, harness: Pick<ScanHarness, "layout" | "dialect">): InstructionWeight | null;
 /** Scan a plugin/repo directory and report its surfaces + structural issues. */
 export declare function scanPlugin(dir: string, layout: PluginLayout, dialect: HarnessDialect, opts?: {
     sharedDirs?: readonly string[];

package/dist/scan.js

@@ -27,6 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureInstructionWeight = measureInstructionWeight;
 exports.scanPlugin = scanPlugin;
 exports.verifyLiveMcpTools = verifyLiveMcpTools;
 exports.formatMcpContractReport = formatMcpContractReport;
@@ -153,6 +154,25 @@ function ownTestSignalOnDisk(dir) {
         existsSync: node_fs_1.existsSync,
     });
 }
+/**
+ * The always-loaded instruction weight of ONE directory under ONE harness —
+ * the bounded read, the harness's chain, and the sum, in one place.
+ *
+ * `scanPlugin` reports it, `lint`'s instruction-weight ratchet gates on it and
+ * `compile` prints it, so all three must arrive at the same number by the same
+ * route; this function is that route. `null` when the harness publishes no
+ * budget (there is no unit to count in).
+ */
+function measureInstructionWeight(dir, harness) {
+    // No `exclude` parameter, on purpose — see the note in `scanPlugin`.
+    return weighBoundedInstructions(harness, (0, surface_discovery_fs_js_1.boundedInstructionFiles)((0, node_path_1.resolve)(dir), harness.layout));
+}
+function weighBoundedInstructions(harness, instructionFiles) {
+    const budget = harness.dialect.instructionBudget;
+    return budget
+        ? (0, instruction_weight_js_1.weighInstructions)(harness.layout.instructionChain(instructionFiles), instructionFiles, budget)
+        : null;
+}
 /** Scan a plugin/repo directory and report its surfaces + structural issues. */
 function scanPlugin(dir, layout, dialect, opts = {}) {
     const lay = layout;
@@ -195,7 +215,15 @@ function scanPlugin(dir, layout, dialect, opts = {}) {
     // expanded an ADAPTER's globs by walking the whole tree; the bound and the
     // classification are now separate jobs held by separate modules, and only the
     // second is the adapter's. See `core/instruction-chain.ts`.
-    const instructionFiles = (0, surface_discovery_fs_js_1.boundedInstructionFiles)((0, node_path_1.resolve)(dir), instructionHarness.layout, opts.excludes);
+    //
+    // 🔴 `exclude` DOES NOT REACH IT. `exclude` means "vigiles does not lint
+    // this"; the harness still loads the file, so hiding it from the weight
+    // under-reports — and since the weight is a committed baseline, one more
+    // `exclude` line would silently lower the ratchet. The harness's own
+    // `claudeMdExcludes` is the channel that removes a file, because it is also
+    // what stops the harness loading it. The browser twin never applied `exclude`
+    // here either, so this is also where the two engines agree.
+    const instructionFiles = (0, surface_discovery_fs_js_1.boundedInstructionFiles)((0, node_path_1.resolve)(dir), instructionHarness.layout);
     const instructions = loaded.files[instructionFile] !== undefined
         ? {
             file: instructionFile,
@@ -321,9 +349,7 @@ function scanPlugin(dir, layout, dialect, opts = {}) {
         // unit (Claude Code counts 40 000 chars, Codex 32 768 bytes), so there is no
         // meaningful sum across two; reporting the one that owns the file that
         // exists is the only reading that is true of something.
-        instructionWeight: instructionHarness.dialect.instructionBudget
-            ? (0, instruction_weight_js_1.weighInstructions)(instructionHarness.layout.instructionChain(instructionFiles), instructionFiles, instructionHarness.dialect.instructionBudget)
-            : null,
+        instructionWeight: weighBoundedInstructions(instructionHarness, instructionFiles),
         untested: coverage.untested.length,
         untestedHarness: coverage.harness.untested.length,
         unevaluated: coverage.evals.untested.length,

package/dist/vigilesrc.schema.json

@@ -1519,6 +1519,42 @@
               "const": true
             }
           ]
+        },
+        "instruction-weight": {
+          "anyOf": [
+            {
+              "type": "string",
+              "const": "warn"
+            },
+            {
+              "type": "string",
+              "const": "error"
+            },
+            {
+              "type": "boolean",
+              "const": false
+            },
+            {
+              "type": "string",
+              "const": "off"
+            },
+            {
+              "type": "number",
+              "const": 0
+            },
+            {
+              "type": "number",
+              "const": 1
+            },
+            {
+              "type": "number",
+              "const": 2
+            },
+            {
+              "type": "boolean",
+              "const": true
+            }
+          ]
         }
       },
       "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigiles",
-  "version": "32.0.1",
+  "version": "32.1.0",
   "description": "Audit, test and measure the harness your AI agent runs on — grade your CLAUDE.md / AGENTS.md, skills, subagents and hooks, run them against a scripted model, and measure whether they actually fire.",
   "keywords": [
     "claude-code",