vigiles 29.0.0 → 30.0.0

package/dist/core/instruction-chain.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTRUCTION_SHAPES = exports.EMPTY_CHAIN = void 0;
+exports.siblingNamed = siblingNamed;
+exports.settingsSources = settingsSources;
+exports.settingsSourcePaths = settingsSourcePaths;
+exports.isInstructionShaped = isInstructionShaped;
+exports.instructionCandidatePaths = instructionCandidatePaths;
+exports.isRepoRootedImport = isRepoRootedImport;
+exports.resolveImportPath = resolveImportPath;
+exports.resolveImports = resolveImports;
+const layout_js_1 = require("./layout.js");
+/** An empty chain — the answer for a harness with no instruction surface. */
+exports.EMPTY_CHAIN = {
+    loaded: [],
+    unloaded: [],
+    imports: [],
+    patterns: [],
+    redirects: [],
+};
+/**
+ * The SHAPE of an instruction candidate — the domain's bound, stated the same
+ * way `SURFACE_SHAPES` states the surface one, and for the same reason: if an
+ * adapter could add a root we would be back to "registering an adapter widens
+ * the read in everyone's repository".
+ *
+ * These are CROSS-VENDOR shapes, not one harness's paths. `rules` is the name
+ * Claude Code (`.claude/rules`), Cursor (`.cursor/rules`) and Windsurf
+ * (`.windsurf/rules`) all use; the dot-directory is the variable, the shape name
+ * is not. Nothing here spells a harness's own directory.
+ *
+ * ⚠️ WHAT THIS CANNOT SEE, stated rather than assumed: a nested
+ * `packages/x/AGENTS.md` (neither vendor loads it at a root session — the chain
+ * classifies one as on-demand if it is handed one, and never goes looking);
+ * `~/.claude/CLAUDE.md`, `~/.codex/AGENTS.md` and every other home-directory
+ * file (reading `~` for a grade is wrong on its face); and a repo-configured
+ * fallback instruction name that is not markdown, because the root entry below
+ * is bounded to `.md` rather than to "every file in the repo root". That last
+ * one under-reports, which is the wrong direction, and it is the price of not
+ * reading a lockfile to grade a harness.
+ */
+exports.INSTRUCTION_SHAPES = [
+    { what: "root markdown", re: /^[^/]+\.md$/ },
+    { what: "dot-directory markdown", re: /^\.[^/]+\/[^/]+\.md$/ },
+];
+/**
+ * 🔴 THE RULES TREE IS NOT IN THE TABLE ABOVE, and that is the fix for #271.
+ *
+ * It used to be, as `/^\.[^/]+\/rules\/…/` — a shape that spelled the word
+ * `rules` itself and demanded a leading dot. Measured against three layouts
+ * built from the TYPE rather than taken from the registry, it answered the same
+ * thing for all of them:
+ *
+ *   rulesDir "rules", no userSurfaceRoot   -> `rules/a.md` NOT a candidate
+ *   rulesDir "guidelines" under `.x`       -> `.x/guidelines/a.md` NOT a candidate
+ *   no rulesDir at all                     -> `.github/rules/a.md` IS a candidate
+ *
+ * Three wrong answers of two kinds: a home the layout DECLARED going unread,
+ * and somebody else's tree being read for a layout that declared none. The
+ * second is the same defect `ruleFileRe` was created for one commit earlier —
+ * fixed there for the CLASSIFIER and left standing here in the BOUND, which is
+ * exactly the "two readers, one fact" split this port exists to remove.
+ *
+ * So the bound asks the layout, through the same function the classifier uses.
+ * This does not let an adapter widen the bound: `rulesDir` is a directory NAME,
+ * the regexp is anchored at the repository root, and a layout that declares no
+ * rules home gets `null` and matches nothing.
+ */
+function isDeclaredRuleFile(path, layout) {
+    const re = (0, layout_js_1.ruleFileRe)(layout);
+    return re !== null && re.test(path);
+}
+/**
+ * The files that carry SETTINGS for one layout — the parse target and the
+ * per-machine override beside it.
+ *
+ * 🔴 A SETTINGS SOURCE IS NOT AN INSTRUCTION, and keeping the two roles apart
+ * is the whole point of this function having its own name. These files are
+ * handed to `instructionChain` and are never weighed, never appear in `loaded`
+ * and never get a `role`: they are not read TO the model, they decide WHICH
+ * files are. Claude Code's `claudeMdExcludes` and Codex's
+ * `project_doc_fallback_filenames` both live in one, which is why they are in
+ * the bound at all.
+ *
+ * The `.local` sibling is DERIVED from `settingsPath` rather than listed,
+ * because a second list is the defect this whole redesign removes. It is
+ * advisory for the same reason `scope: "local"` is: it is gitignored by
+ * convention, so the browser twin can never see it, and anything that DEPENDED
+ * on it would make the two engines disagree. It can only narrow what loads.
+ */
+/**
+ * `AGENTS.md` + `override` → `AGENTS.override.md`; `settings.json` + `local` →
+ * `settings.local.json`. The ONE place the "sibling file" spelling lives.
+ *
+ * Both vendors name a per-machine file by inserting a word before the
+ * extension, and they choose DIFFERENT words — Claude Code `local`, Codex
+ * `override` — so the word is the argument and the spelling is not. A file with
+ * no extension gets the word appended, which is the only reading that does not
+ * invent a dot.
+ */
+function siblingNamed(path, infix) {
+    const dot = path.lastIndexOf(".");
+    const slash = path.lastIndexOf("/");
+    return dot > slash && dot > slash + 1
+        ? `${path.slice(0, dot)}.${infix}${path.slice(dot)}`
+        : `${path}.${infix}`;
+}
+/**
+ * The settings files in precedence order, each carrying its SCOPE.
+ *
+ * The scope is the whole point: a pattern read out of a gitignored sibling may
+ * not change what a teammate on this commit is scored for. Callers that only
+ * need the paths use {@link settingsSourcePaths}, which is this list flattened.
+ */
+function settingsSources(layout) {
+    const infix = layout.settingsLocalInfix;
+    const committed = {
+        path: layout.settingsPath,
+        scope: "repo",
+    };
+    return infix === undefined
+        ? [committed]
+        : [
+            committed,
+            { path: siblingNamed(layout.settingsPath, infix), scope: "local" },
+        ];
+}
+function settingsSourcePaths(layout) {
+    // DECLARED, not derived — see `PluginLayout.settingsLocalInfix` for the
+    // measurement. A harness that names no infix has no per-machine settings
+    // layer, and inventing one for it manufactures a file to read.
+    return settingsSources(layout).map((s) => s.path);
+}
+/** Does this repo-relative path match one of the {@link INSTRUCTION_SHAPES}? */
+function isInstructionShaped(path) {
+    return exports.INSTRUCTION_SHAPES.some((s) => s.re.test(path));
+}
+/**
+ * The bounded candidate set: every path a harness may be ASKED about.
+ *
+ * Pure and storage-blind on purpose, exactly as `discoverSurfaces` is — the
+ * disk walk (`src/surface-discovery-fs.ts`) and the browser file-map twin
+ * (`src/scan-files.ts`) each enumerate from their own storage and call THIS for
+ * the decision, so the pair cannot disagree about what is a candidate.
+ */
+function instructionCandidatePaths(paths, layout) {
+    const named = new Set([
+        layout.instructionFile,
+        ...settingsSourcePaths(layout),
+    ]);
+    return paths.filter((p) => named.has(p) || isInstructionShaped(p) || isDeclaredRuleFile(p, layout));
+}
+/**
+ * Is `token` a path this repo could hold, and safe to resolve against its root?
+ *
+ * Refuses an absolute path, a `~` home reference, and anything with a `..`
+ * segment — an instruction file that points outside the repository is not a
+ * fact about the repository, and following it would let a file decide what
+ * vigiles opens on the machine running it.
+ */
+function isRepoRootedImport(token) {
+    if (token === "" || token.startsWith("/") || token.startsWith("~")) {
+        return false;
+    }
+    if (/^[A-Za-z]:/.test(token) || token.includes("\\"))
+        return false;
+    return !token.split("/").includes("..");
+}
+/**
+ * Where an `@import` token inside `from` actually points.
+ *
+ * 🔴 RELATIVE TO THE IMPORTING FILE, NOT TO THE REPOSITORY ROOT, and that is a
+ * MEASUREMENT rather than a reading of the docs — Claude Code 2.1.278, fixture
+ * `q3-relative` in `test/fixtures/instruction-chain-vendor/`. The case is built
+ * so the answer cannot be "it found nothing": `.claude/CLAUDE.md` holds
+ * `@notes.md` and BOTH candidates exist, each with its own codeword.
+ *
+ *   recited: SAIGA-8181 (`.claude/notes.md`)   not TAPIR-6262 (`notes.md`)
+ *   hook:    .claude/notes.md  load_reason: include  parent: .claude/CLAUDE.md
+ *
+ * Resolving against the root instead reports that file unread and charges the
+ * weight of a DIFFERENT file that happens to share its name — wrong in both
+ * directions at once, and silent.
+ *
+ * ⚠️ A TOKEN WITH `..` STAYS REFUSED even though this resolution would make
+ * some of them land inside the repository (`@../notes.md` from `.claude/`).
+ * {@link isRepoRootedImport} rejects them before this is called, and lifting
+ * that is a separate decision needing its own fixture: the refusal is what
+ * stops an instruction file deciding what vigiles opens on the machine running
+ * it, and "it happens to stay inside" is a property of one path, not a rule.
+ */
+function resolveImportPath(from, token) {
+    const slash = from.lastIndexOf("/");
+    const dir = slash === -1 ? "" : from.slice(0, slash + 1);
+    // 🔴 EVERY `.` SEGMENT, NOT JUST THE LEADING ONE. A first fix stripped
+    // `^(\./)+` only, which made `@./notes.md` and `@notes.md` one key and left
+    // `@docs/./style.md` as `docs/./style.md`. That is invisible on disk — `join`
+    // normalises it for the reader — and wrong in the browser, whose file map is
+    // keyed `docs/style.md`: the file is reported unread and its bytes vanish
+    // from the weight. Two engines, one path, and only one of them normalising is
+    // the disagreement the shared candidate set exists to prevent.
+    //
+    // `..` is NOT handled here and must not be: `isRepoRootedImport` refuses those
+    // tokens before this is called, and collapsing one would quietly turn a
+    // refused path into an accepted one.
+    return `${dir}${token}`
+        .split("/")
+        .filter((seg, i, all) => seg !== "." && (seg !== "" || i === all.length - 1))
+        .join("/");
+}
+/**
+ * Read the `@import` paths the loaded files NAME — ONE LEVEL, no recursion.
+ * Returns a NEW map: the candidates handed in, plus whatever they named.
+ *
+ * 🔴 THIS READS OUTSIDE THE DOT-DIRECTORY BOUND, DELIBERATELY, AND THE REASON IS
+ * WHO CHOSE THE PATH. The bound exists so that REGISTERING AN ADAPTER cannot
+ * widen what vigiles reads in someone else's repository. An `@import` token is a
+ * concrete path written by the REPOSITORY OWNER in their own instruction file;
+ * the adapter only finds it, and `adapter-properties.test.ts` asserts exactly
+ * that — every reported import literally occurs in the file that reports it.
+ *
+ * 🔴 ONE LEVEL IS A MEASUREMENT, NOT A SHORTCUT — DO NOT "IMPROVE" IT INTO A
+ * RECURSIVE PASS. Across a corpus of 198 real `CLAUDE.md` files scraped from
+ * public repositories (July sample; the grep finds `@name.md` shapes only),
+ * exactly SIX files carried an import at all — 3%:
+ *
+ *     4  @AGENTS.md
+ *     1  @docs/architecture.md
+ *     1  @.maister/docs/INDEX.md
+ *
+ * Every one is a single concrete path at depth 1. Nothing in that corpus needs
+ * recursion, a depth budget or an exclude pass, and a recursive walk driven by
+ * strings found in files is the exact defect zernie/vigiles#262 is about.
+ *
+ * 🔴 AND THE SAME IS NOW MEASURED FOR `AGENTS.md`, WHICH USED TO BE THE HOLE IN
+ * THIS BOUND. The corpus above is `CLAUDE.md` BY CONSTRUCTION, so it said
+ * nothing about the family Claude Code reads natively since v2.1.277 — and a
+ * one-level bound justified by a corpus that could not contain the file is not
+ * justified, it is extrapolated. Measured over the same sample, by the same
+ * method, carrying the same two caveats (July sample of public repositories;
+ * the grep finds `@name.md` shapes only): 214 real `AGENTS.md` files, THREE
+ * carry an import at all — 1.4%:
+ *
+ *     1  @tasks/BASED.md
+ *     1  @ai-rules/rule-loading.md
+ *     1  @AGENTS.local.md
+ *
+ * Every one is a single concrete path at depth 1 — the same SHAPE and the same
+ * RARITY as the six on the `CLAUDE.md` side (3%). So one level is measured on
+ * both families rather than assumed to carry over from one.
+ *
+ * ⏳ THE THIRD OF THOSE THREE IS NOT AN ORDINARY IMPORT, and it is an OPEN
+ * QUESTION rather than a decided one: `AGENTS.local.md` is a name Claude Code
+ * lists under "Not read", so an explicit `@` token names a file the loader may
+ * never open. Both readings and the observation that settles them are at
+ * `isNeverRead` in `adapters/claude-code/instruction-chain.ts` — one harness's
+ * list belongs in one harness's adapter, not in the domain.
+ *
+ * ⚠️ AND THE VENDOR PUTS A NUMBER ON THE THING THIS BOUND APPROXIMATES, which
+ * the measurement above does not repeal: "Imported files can recursively import
+ * other files, with a maximum depth of FOUR HOPS" (same page, read 2026-09-21).
+ * So one level is a bound on what this reads, chosen because neither corpus has
+ * a second hop — not a claim that a second hop cannot exist. A repository that
+ * uses them is under-reported by the nested size, and the honest form of that
+ * is the sentence below rather than a depth counter nothing exercises.
+ *
+ * 🔴 AND THE SIX ARE WHERE THE NUMBER IS MOST WRONG WITHOUT THIS PASS. Four of
+ * them are `@AGENTS.md` — the workaround for Claude Code not yet reading
+ * `AGENTS.md` natively (anthropics/claude-code#34235; reversed in v2.1.277, see
+ * `adapters/claude-code/dialect.ts`). Skipping imports would still miss that
+ * file's whole size in exactly those repositories, because the vendor's rule is
+ * that a `CLAUDE.md` SUPPRESSES `AGENTS.md` — so the import is the only way in,
+ * and dropping it is an under-report, which reads as "you are fine".
+ *
+ * ⚠️ WHAT ONE LEVEL COSTS, stated rather than implied: a transitive import (an
+ * imported file that imports again) is a real Claude Code feature, and its
+ * nested size is NOT counted. NEITHER corpus — 198 `CLAUDE.md`, 214
+ * `AGENTS.md`, 412 files, nine imports between them — holds one; if a real case
+ * shows up, those measurements are the thing to redo, not this loop.
+ */
+function resolveImports(layout, files, read) {
+    const out = { ...files };
+    for (const { path } of layout.instructionChain(files).imports) {
+        if (out[path] !== undefined || !isRepoRootedImport(path))
+            continue;
+        const text = read(path);
+        if (text !== undefined)
+            out[path] = text;
+    }
+    return out;
+}
+//# sourceMappingURL=instruction-chain.js.map

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

@@ -35,6 +35,7 @@
  * first consumer is `audit`, as a REPORT. It earns a severity when a corpus
  * exists that it would not immediately fail.
  */
+import type { InstructionChain, InstructionRole, InstructionScope } from "./instruction-chain.js";
 /** What the harness counts, and what it does when the count is exceeded. */
 export interface InstructionBudget {
     /** Claude Code counts characters; Codex counts bytes. Never tokens. */
@@ -50,17 +51,53 @@ export interface InstructionBudget {
     readonly onExceed: "warns" | "truncates";
     /** The vendor artifact this was read from, version included. */
     readonly capturedFrom: string;
-    /**
-     * Globs the harness loads WITHOUT the user asking — the set the SUM is taken
-     * over. A file reachable only by an explicit read does not belong here; that
-     * is exactly the distinction the relocation trick exploits.
-     */
-    readonly alwaysLoaded: readonly string[];
 }
 /** One file's contribution, so a report can say WHERE the weight is. */
 export interface WeighedFile {
     readonly path: string;
     readonly size: number;
+    /** What it is to the harness — a root file, a rule, an import. */
+    readonly role: InstructionRole;
+    /** `"local"` files are shown and never scored; see {@link InstructionScope}. */
+    readonly scope: InstructionScope;
+    /**
+     * Set when this file got into the count through an IMPORT — who named it, and
+     * with what text. The report prints it on the file's own line, because
+     * `AGENTS.md` appearing in a Claude Code weight reads as a bug until the line
+     * says `via @AGENTS.md in CLAUDE.md`. A total a reader cannot decompose is the
+     * failure this report exists to prevent.
+     */
+    readonly via?: {
+        readonly from: string;
+        readonly token: string;
+    };
+    /**
+     * Set when this file pays into {@link InstructionWeight.committedTotal} but
+     * NOT into {@link InstructionWeight.effectiveTotal}: a PER-MACHINE file in
+     * this working copy supersedes it, so a teammate on the same commit loads it
+     * and you do not. Names the file that did it.
+     *
+     * 🔴 THE ONE CASE WHERE THE TWO TOTALS MOVE IN OPPOSITE DIRECTIONS, and the
+     * reason this is a field rather than a filter at the print site. Every other
+     * per-machine effect is ADDITIVE — a `CLAUDE.local.md` appends its own bytes,
+     * so `effective = committed + locals` — which is why it was safe for
+     * `effectiveTotal` to be "the sum of everything loaded". Claude Code's
+     * supersede rule breaks that: "Because `CLAUDE.local.md` counts, adding one
+     * to keep your own uncommitted instructions in a project that relies on
+     * `AGENTS.md` stops Claude from reading `AGENTS.md` for you." The gitignored
+     * file changes the MEMBERSHIP of the load, not its size, and the committed
+     * number has to keep a file this working copy never opens.
+     *
+     * A reader who could not see this on the file's own line would meet a
+     * `committedTotal` larger than the `effectiveTotal` beside it with nothing
+     * accounting for the gap — the undecomposable total this whole report exists
+     * to prevent.
+     */
+    readonly notLoadedHere?: {
+        /** The per-machine file that did it — a superseder, or a settings file. */
+        readonly by: string;
+        readonly why: "superseded" | "excluded";
+    };
 }
 export interface InstructionWeight {
     readonly unit: "chars" | "bytes";
@@ -68,19 +105,64 @@ export interface InstructionWeight {
     readonly onExceed: "warns" | "truncates";
     /** Heaviest first — a report's first line should name the biggest payer. */
     readonly files: readonly WeighedFile[];
-    /** The number that matters: everything loaded without a decision. */
-    readonly total: number;
-    /** `null` when within budget; otherwise how far over, in `unit`. */
+    /**
+     * The SCORED number: everything loaded without a decision that a TEAMMATE or
+     * CI would also load. Per-machine files are excluded, which is what makes the
+     * figure reproducible from a commit alone.
+     */
+    readonly committedTotal: number;
+    /**
+     * What THIS working copy actually loads. Never compared against the budget;
+     * printed beside it so the difference is visible rather than silently either
+     * counted or dropped.
+     *
+     * ⚠️ IT IS NOT "`committedTotal` PLUS THE PER-MACHINE FILES", and it used to
+     * say so. A per-machine file can also SUBTRACT: Claude Code stops reading
+     * `AGENTS.md` at all once a `CLAUDE.local.md` exists, so this number can come
+     * out BELOW `committedTotal`. See {@link WeighedFile.supersededLocallyBy}.
+     */
+    readonly effectiveTotal: number;
+    /** `null` when {@link committedTotal} is within budget; else how far over. */
     readonly overBy: number | null;
+    /**
+     * Files the chain NAMED and this run did not read — an import that does not
+     * exist, points outside the repo, or sits past the import depth. Printed, not
+     * dropped: a number missing a file it knows about would be the under-report
+     * this whole module exists to prevent.
+     */
+    readonly unreadImports: readonly string[];
+    /**
+     * Globs and URLs the harness would expand at launch and vigiles will not walk
+     * (OpenCode `instructions`). Reported for the same reason.
+     */
+    readonly unweighedPatterns: readonly string[];
+    /**
+     * A loaded file whose ENTIRE content is import tokens. Printed as a FINDING,
+     * not as a size: such a `CLAUDE.md` is fourteen bytes and the repository it
+     * describes loads tens of kilobytes, so the number on its own is a confident
+     * wrong answer. See `InstructionChain.redirects` for why the shape is common.
+     */
+    readonly redirects: readonly {
+        readonly path: string;
+        readonly to: readonly string[];
+    }[];
 }
 /** Size in the harness's own unit. Bytes and chars differ on any non-ASCII text. */
 export declare function sizeIn(text: string, unit: "chars" | "bytes"): number;
 /**
- * Weigh every unconditionally-loaded file in a file map.
+ * Weigh a harness's LOADED chain against its own budget.
+ *
+ * 🔴 IT TAKES A CHAIN, NOT A GLOB LIST, AND THAT IS THE WHOLE FIX. This used to
+ * filter the file map with `matchesGlob` over `budget.alwaysLoaded` — an adapter
+ * string the core interpreted — and so it counted files the harness does not
+ * load at launch (`paths:`-scoped rules, a sibling package's instruction file)
+ * and a file no teammate has (`CLAUDE.local.md`). Which files load is the
+ * harness's answer now (`PluginLayout.instructionChain`); this function only
+ * adds up what it was told and says what it could not weigh.
  *
- * Takes a MAP rather than a directory so the same function serves the CLI and
- * the browser engine (the `scan-files.ts` split), and so a test states its
- * input instead of building a tree.
+ * Takes the map as well as the chain because a chain is a CLASSIFICATION, not
+ * a measurement: the sizes live in the bytes, and the same map serves the CLI
+ * and the browser engine.
  */
-export declare function weighInstructions(files: Readonly<Record<string, string>>, budget: InstructionBudget): InstructionWeight;
+export declare function weighInstructions(chain: InstructionChain, files: Readonly<Record<string, string>>, budget: InstructionBudget): InstructionWeight;
 //# sourceMappingURL=instruction-weight.d.ts.map

package/dist/core/instruction-weight.js

@@ -44,43 +44,78 @@ function sizeIn(text, unit) {
     return unit === "chars" ? text.length : Buffer.byteLength(text, "utf8");
 }
 /**
- * Match a path against one glob. Deliberately tiny: the patterns here are
- * `alwaysLoaded` entries an ADAPTER writes, not user input — `CLAUDE.md`,
- * `.claude/rules/**`. `*` stops at a separator, `**` crosses them.
- */
-function matchesGlob(path, glob) {
-    const rx = glob
-        .split(/(\*\*\/|\*\*|\*)/)
-        .map((part) => part === "**/"
-        ? "(?:.*/)?"
-        : part === "**"
-            ? ".*"
-            : part === "*"
-                ? "[^/]*"
-                : part.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
-        .join("");
-    return new RegExp(`^${rx}$`).test(path);
-}
-/**
- * Weigh every unconditionally-loaded file in a file map.
+ * Weigh a harness's LOADED chain against its own budget.
  *
- * Takes a MAP rather than a directory so the same function serves the CLI and
- * the browser engine (the `scan-files.ts` split), and so a test states its
- * input instead of building a tree.
+ * 🔴 IT TAKES A CHAIN, NOT A GLOB LIST, AND THAT IS THE WHOLE FIX. This used to
+ * filter the file map with `matchesGlob` over `budget.alwaysLoaded` — an adapter
+ * string the core interpreted — and so it counted files the harness does not
+ * load at launch (`paths:`-scoped rules, a sibling package's instruction file)
+ * and a file no teammate has (`CLAUDE.local.md`). Which files load is the
+ * harness's answer now (`PluginLayout.instructionChain`); this function only
+ * adds up what it was told and says what it could not weigh.
+ *
+ * Takes the map as well as the chain because a chain is a CLASSIFICATION, not
+ * a measurement: the sizes live in the bytes, and the same map serves the CLI
+ * and the browser engine.
  */
-function weighInstructions(files, budget) {
-    const weighed = Object.entries(files)
-        .filter(([path]) => budget.alwaysLoaded.some((g) => matchesGlob(path, g)))
-        .map(([path, text]) => ({ path, size: sizeIn(text, budget.unit) }))
-        .sort((a, b) => b.size - a.size || a.path.localeCompare(b.path));
-    const total = weighed.reduce((sum, f) => sum + f.size, 0);
+function weighInstructions(chain, files, budget) {
+    const notLoadedHere = chain.unloaded.flatMap((e) => {
+        if (e.scope !== "repo")
+            return [];
+        if (e.reason.kind === "superseded" && e.reason.byScope === "local") {
+            return [{ entry: e, by: e.reason.by, why: "superseded" }];
+        }
+        if (e.reason.kind === "excluded-by-settings" &&
+            e.reason.byScope === "local") {
+            return [{ entry: e, by: e.reason.by, why: "excluded" }];
+        }
+        return [];
+    });
+    const weighOne = (entry, notLoadedHereBy) => {
+        const text = files[entry.path];
+        return text === undefined
+            ? []
+            : [
+                {
+                    path: entry.path,
+                    size: sizeIn(text, budget.unit),
+                    role: entry.role,
+                    scope: entry.scope,
+                    ...(entry.via === undefined ? {} : { via: entry.via }),
+                    ...(notLoadedHereBy === undefined
+                        ? {}
+                        : { notLoadedHere: notLoadedHereBy }),
+                },
+            ];
+    };
+    const weighed = [
+        ...chain.loaded.flatMap((e) => weighOne(e)),
+        ...notLoadedHere.flatMap((s) => weighOne(s.entry, { by: s.by, why: s.why })),
+    ].sort((a, b) => b.size - a.size || a.path.localeCompare(b.path));
+    const sum = (of) => of.reduce((total, f) => total + f.size, 0);
+    // COMMITTED is still "every `repo`-scoped file in the list", unchanged — the
+    // superseded entry is a committed file and joins the list with `scope:
+    // "repo"`, so the formula did not have to learn a second rule. EFFECTIVE is
+    // the one that changed: it was `sum(weighed)`, which was only ever right
+    // while the list held nothing this working copy fails to load.
+    const committedTotal = sum(weighed.filter((f) => f.scope === "repo"));
     return {
         unit: budget.unit,
         limit: budget.limit,
         onExceed: budget.onExceed,
         files: weighed,
-        total,
-        overBy: total > budget.limit ? total - budget.limit : null,
+        committedTotal,
+        effectiveTotal: sum(weighed.filter((f) => f.notLoadedHere === undefined)),
+        overBy: committedTotal > budget.limit ? committedTotal - budget.limit : null,
+        unreadImports: [
+            ...new Set(chain.imports
+                .map((i) => i.path)
+                .filter((path) => files[path] === undefined)),
+        ].sort(),
+        unweighedPatterns: [
+            ...new Set(chain.patterns.map((p) => p.pattern)),
+        ].sort(),
+        redirects: chain.redirects,
     };
 }
 //# sourceMappingURL=instruction-weight.js.map