vigiles 12.7.0 → 13.0.0

package/dist/rule-routing.d.ts

@@ -0,0 +1,46 @@
+import { type LinterName } from "./rule-inventory.js";
+/** How a routed rule would be enforced (a MECHANISM ladder, not a 1-10 score). */
+export type RuleCategory = "reuse" | "hook" | "semantic" | "unrouted";
+export type RuleMechanism = "config-line" | "hook" | "prose" | "compile";
+/** One segmented, deterministically-routed rule with provenance. */
+export interface RoutedRule {
+    /** Normalized atomic rule text (from the segmenter). */
+    readonly text: string;
+    /** Verbatim source slice — for a UI highlight. */
+    readonly quote: string;
+    readonly file: string | undefined;
+    readonly lineStart: number;
+    readonly lineEnd: number;
+    /** Segmenter confidence that this IS a rule (3/3 cues → high, 2/3 → medium). */
+    readonly confidence: "high" | "medium";
+    readonly category: RuleCategory;
+    readonly mechanism: RuleMechanism;
+    /** reuse only: the off-the-shelf rule that enforces it. */
+    readonly rule?: string;
+    /** reuse only: the linter that rule belongs to. */
+    readonly linter?: LinterName;
+}
+export interface RuleRouting {
+    /** How many atomic rules were routed (after the confidence filter). */
+    readonly segmented: number;
+    readonly counts: Record<RuleCategory, number>;
+    readonly rules: readonly RoutedRule[];
+}
+export interface RouteOptions {
+    /**
+     * Minimum segmenter confidence to route. The segmenter emits `high` (3/3 cues
+     * — an imperative rule) and `medium` (2/3). For the audit PREVIEW we default to
+     * `high` only: precision over recall. A doc-heavy instruction file (e.g. a
+     * keyFiles index of "`path` — description" bullets) trips the medium tier with
+     * non-rules, which would bury the real rules and overstate "unrouted". Pass
+     * `"medium"` to include both.
+     */
+    readonly minConfidence?: "high" | "medium";
+}
+/**
+ * Segment the instruction file and route every atomic rule deterministically.
+ * Pure: the caller passes the concatenated instruction text (and an optional
+ * source path for provenance). Returns per-category counts + the routed rules.
+ */
+export declare function routeRules(instructionText: string, file?: string, options?: RouteOptions): RuleRouting;
+//# sourceMappingURL=rule-routing.d.ts.map

package/dist/rule-routing.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeRules = routeRules;
+/**
+ * rule-routing.ts — the deterministic (no-model) State-B routing PREVIEW.
+ *
+ * `rule-inventory.ts` answers a narrow question ("which prose lines name an
+ * off-the-shelf lint rule, and is it enabled?"). This goes one honest step
+ * further: it SEGMENTS the whole instruction file into atomic rules
+ * ({@link segmentInstructions}) and routes each one into the class that a real
+ * enforcement path would take — WITHOUT running a model:
+ *
+ *   reuse    → the rule text names an off-the-shelf lint rule ({@link INTENT_MAP})
+ *              → mechanism: flip one config line.
+ *   hook     → an ACTION rule a linter can't see (git push, rm -rf, "before you
+ *              commit") → mechanism: a pre-commit / PreToolUse hook.
+ *   semantic → a judgment call ("readable", "single responsibility") no checker
+ *              can honestly decide → mechanism: stays prose.
+ *   unrouted → none of the above fired deterministically → mechanism: the opt-in
+ *              `compile` tier routes it (reuse / synthesize / hook / prose).
+ *
+ * HONESTY BY CONSTRUCTION: the deterministic tier NEVER claims a rule is
+ * "synthesizable" — deciding that a custom rule can be written (and gating it)
+ * is exactly the work the opt-in model tier does. Everything this file can't
+ * pin to a concrete cue is `unrouted` ("compile to find out"), not a promise.
+ *
+ * Pure, deterministic, dependency-free. Reuses `rule-inventory`'s hardened
+ * whole-token matcher + `INTENT_MAP`, and `segment`'s Tier-A segmenter.
+ */
+const segment_js_1 = require("./segment.js");
+const rule_inventory_js_1 = require("./rule-inventory.js");
+/** The mechanism each category maps to — a fixed, honest ladder. */
+const MECHANISM = {
+    reuse: "config-line",
+    hook: "hook",
+    semantic: "prose",
+    unrouted: "compile",
+};
+/**
+ * ACTION-rule cues — things a linter never sees (git, filesystem, shell,
+ * process). A hook is the right gate, not a lint rule. Ported from the compiler's
+ * classifier; deliberately specific so it doesn't grab a lint rule that merely
+ * mentions a file.
+ */
+const HOOK_CUES = [
+    /\bgit\s+push\b/i,
+    // "push … to main/master/prod" — tolerate backticks/adverbs between (real
+    // phrasings: "push directly to `main`", "pushing straight to master").
+    /\bpush\w*\b[^.\n]{0,24}\b(main|master|prod)\b/i,
+    /\bforce[- ]?push/i,
+    /--no-verify/i,
+    /\bnever\s+commit\b/i,
+    // "before you/each/every commit", "before committing".
+    /\bbefore\s+(you\s+|each\s+|every\s+)?commit(ting)?\b/i,
+    /\brun\b[^.\n]{0,20}\btests?\b[^.\n]{0,14}\bbefore\b/i,
+    /\bsigned-off-by\b/i,
+    /\b(don'?t|do not|never)\s+edit\b.*\b(generated|\.pb\.|_mock|proto-gen|lock)/i,
+    /\bgenerated\s+files?\b/i,
+    /\bco[- ]?authored[- ]?by\b/i,
+    /\brm\s+-rf\b/i,
+    /\bcurl\b.*\|\s*(sh|bash)/i,
+    /\bchmod\b/i,
+];
+/**
+ * Judgment / no-checker cues — a rule no linter can honestly decide, so it stays
+ * labeled prose. Ported from the compiler's classifier (the static markers only —
+ * no ruleMap dependency, to keep this file model-free and dep-free).
+ */
+const SEMANTIC_CUES = [
+    /\bself[- ]?documenting\b/i,
+    /\bclear(er)?\s+(names?|code|over clever)/i,
+    /\breadable\b/i,
+    /\bkeep it simple\b/i,
+    /\bover[- ]?engineer/i,
+    /\bsingle responsibility\b/i,
+    /\bcomposition over inheritance\b/i,
+    /\bmeaningful\b/i,
+    /\bidiomatic\b/i,
+    /\bwhere (it )?makes sense\b/i,
+    /\bappropriate(ly)?\b/i,
+    /\bsolid\s+principles?\b/i,
+    /\bbest practices?\b/i,
+    /\bclean code\b/i,
+];
+/**
+ * Route one atomic rule. Order matters: an ACTION cue (git push) wins over a
+ * rule-name mention ("never commit console.log" is a hook, not a lint rule);
+ * reuse (a concrete off-the-shelf rule) wins over a soft semantic cue.
+ */
+function classify(text) {
+    if (HOOK_CUES.some((re) => re.test(text)))
+        return { category: "hook" };
+    for (const m of rule_inventory_js_1.INTENT_MAP) {
+        if (m.keywords.some((kw) => (0, rule_inventory_js_1.matchesWholeToken)(text, kw))) {
+            return { category: "reuse", rule: m.rule, linter: m.linter };
+        }
+    }
+    if (SEMANTIC_CUES.some((re) => re.test(text)))
+        return { category: "semantic" };
+    return { category: "unrouted" };
+}
+/**
+ * Segment the instruction file and route every atomic rule deterministically.
+ * Pure: the caller passes the concatenated instruction text (and an optional
+ * source path for provenance). Returns per-category counts + the routed rules.
+ */
+function routeRules(instructionText, file, options = {}) {
+    const minConfidence = options.minConfidence ?? "high";
+    const segments = (0, segment_js_1.segmentInstructions)(instructionText, file).filter((s) => minConfidence === "medium" || s.confidence === "high");
+    const rules = segments.map((s) => {
+        const c = classify(s.text);
+        return {
+            text: s.text,
+            quote: s.exactQuote,
+            file: s.file,
+            lineStart: s.lineStart,
+            lineEnd: s.lineEnd,
+            confidence: s.confidence,
+            category: c.category,
+            mechanism: MECHANISM[c.category],
+            ...(c.rule ? { rule: c.rule } : {}),
+            ...(c.linter ? { linter: c.linter } : {}),
+        };
+    });
+    const counts = {
+        reuse: 0,
+        hook: 0,
+        semantic: 0,
+        unrouted: 0,
+    };
+    for (const r of rules)
+        counts[r.category]++;
+    return { segmented: segments.length, counts, rules };
+}
+//# sourceMappingURL=rule-routing.js.map

package/dist/scaffold-test.js

@@ -210,7 +210,7 @@ function safetySection(input, sideEffecting) {
 // --- Safety (deterministic) — generated from ${input.name}'s side-effecting tools: ${sideEffecting.join(", ")} ---
 // In a real run, replace this constructed Trace with a real \`runHarness\` /
 // \`measure\` turn (use interceptTools so a real model's attempt is DENIED, never
-// executed — see docs/eval-architecture.md). The checks below are derived from the
+// executed — see research/eval-architecture.md). The checks below are derived from the
 // declared tools contract — the agent's "hole" asserted to stay in its lane.
 {
   const trace = {

package/dist/segment.d.ts

@@ -0,0 +1,33 @@
+/**
+ * segment.ts — Tier-A deterministic (no-model) segmenter.
+ *
+ * Splits a CLAUDE.md / AGENTS.md into ATOMIC candidate rules with provenance.
+ * Pure, deterministic, strict TS, no external deps.
+ *
+ * Design bias: PRECISION over recall. A missed rule costs a row; a garbage
+ * atom costs credibility. When in doubt we UNDER-split and REJECT.
+ */
+/** A single atomic candidate rule extracted from an instructions file. */
+export interface SegmentedRule {
+    /** Normalized rule text (bullet marker stripped, continuation joined, whitespace collapsed). */
+    text: string;
+    /** Source file path (as supplied by the caller), or undefined. */
+    file: string | undefined;
+    /** 1-based inclusive start line in the source. */
+    lineStart: number;
+    /** 1-based inclusive end line in the source. */
+    lineEnd: number;
+    /** Verbatim slice of the source spanning [lineStart..lineEnd] — for UI highlight. */
+    exactQuote: string;
+    /** 3/3 cues => "high"; 2/3 => "medium". (Rejected candidates are never emitted.) */
+    confidence: "high" | "medium";
+}
+/**
+ * Split a CLAUDE.md / AGENTS.md into atomic candidate rules with provenance.
+ *
+ * Deterministic Tier-A heuristic. Code fences and tables are excluded from
+ * candidacy. Candidate units are (a) list items with attached continuation
+ * lines and (b) sentences of paragraphs under a rule-ish heading.
+ */
+export declare function segmentInstructions(markdown: string, file?: string): SegmentedRule[];
+//# sourceMappingURL=segment.d.ts.map

package/dist/segment.js

@@ -0,0 +1,454 @@
+"use strict";
+/**
+ * segment.ts — Tier-A deterministic (no-model) segmenter.
+ *
+ * Splits a CLAUDE.md / AGENTS.md into ATOMIC candidate rules with provenance.
+ * Pure, deterministic, strict TS, no external deps.
+ *
+ * Design bias: PRECISION over recall. A missed rule costs a row; a garbage
+ * atom costs credibility. When in doubt we UNDER-split and REJECT.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.segmentInstructions = segmentInstructions;
+// --- Heuristic vocabulary --------------------------------------------------
+/** Imperative/prohibitive head the candidate must START with (form cue). */
+const FORM_HEAD = /^(?:use|avoid|prefer|never|always|don'?t|do not|no\s+\S|must|should|keep|run|write|add|remove|only)\b/i;
+/** Rule-ish heading gate for prose-under-heading candidacy. */
+const RULE_HEADING = /rules?|conventions?|style|guidelines?|standards?|do(?:n'?ts?)?s?|never|always|must|require/i;
+/** Declarative subjects — these signal a statement, not an instruction. */
+const DECLARATION = /^(?:this|these|those|it|we|our|there)\b/i;
+/** Line consisting only of a bare URL. */
+const URL_ONLY = /^<?https?:\/\/\S+>?$/;
+/** Line consisting only of a markdown link. */
+const LINK_ONLY = /^\[[^\]]*\]\([^)]*\)$/;
+/** Verb-ish lexicon (secondary shape signal). Kept curated for precision. */
+const VERBS = new Set([
+    "use",
+    "uses",
+    "using",
+    "used",
+    "avoid",
+    "avoids",
+    "prefer",
+    "prefers",
+    "run",
+    "runs",
+    "write",
+    "writes",
+    "writing",
+    "add",
+    "adds",
+    "remove",
+    "removes",
+    "keep",
+    "keeps",
+    "import",
+    "imports",
+    "importing",
+    "split",
+    "splits",
+    "push",
+    "pushes",
+    "commit",
+    "commits",
+    "test",
+    "tests",
+    "call",
+    "calls",
+    "set",
+    "sets",
+    "make",
+    "makes",
+    "create",
+    "creates",
+    "delete",
+    "deletes",
+    "update",
+    "updates",
+    "check",
+    "checks",
+    "ensure",
+    "ensures",
+    "document",
+    "documents",
+    "follow",
+    "follows",
+    "handle",
+    "handles",
+    "return",
+    "returns",
+    "throw",
+    "throws",
+    "catch",
+    "log",
+    "logs",
+    "prefix",
+    "name",
+    "names",
+    "store",
+    "stores",
+    "read",
+    "reads",
+    "save",
+    "saves",
+    "wrap",
+    "wraps",
+    "escape",
+    "escapes",
+    "match",
+    "matches",
+    "filter",
+    "filters",
+    "merge",
+    "merges",
+    "be",
+    "is",
+    "are",
+    "have",
+    "has",
+    "may",
+    "should",
+    "must",
+    "pin",
+    "pins",
+    "lint",
+    "format",
+    "formats",
+    "sort",
+    "group",
+    "groups",
+    "export",
+    "exports",
+    "mock",
+    "stub",
+    "assert",
+    "validate",
+    "validates",
+    "sanitize",
+    "encode",
+    "decode",
+    "hash",
+    "sign",
+    "verify",
+    "verifies",
+    "expose",
+    "hide",
+    "close",
+    "open",
+    "load",
+    "loads",
+    "fetch",
+    "fetches",
+    "render",
+    "renders",
+    "mount",
+    "bind",
+    "inject",
+    "register",
+    "resolve",
+    "reject",
+    "await",
+    "apply",
+    "applies",
+    "bump",
+    "tag",
+    "branch",
+    "rebase",
+    "squash",
+    "enforce",
+    "enforces",
+    "define",
+    "defines",
+    "declare",
+    "place",
+    "put",
+    "prefer",
+]);
+// --- Offset / line utilities ----------------------------------------------
+function computeLineOffsets(lines) {
+    const offsets = new Array(lines.length);
+    let acc = 0;
+    for (let i = 0; i < lines.length; i++) {
+        offsets[i] = acc;
+        acc += lines[i].length + 1; // +1 for the '\n' consumed by split
+    }
+    return offsets;
+}
+function offsetToLine(lineOffsets, off) {
+    // 1-based line number containing char offset `off`.
+    let lo = 0;
+    let hi = lineOffsets.length - 1;
+    let ans = 0;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        if (lineOffsets[mid] <= off) {
+            ans = mid;
+            lo = mid + 1;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return ans + 1;
+}
+function normalize(s) {
+    return s.replace(/\s+/g, " ").trim();
+}
+function hasVerbish(text) {
+    const tokens = text
+        .toLowerCase()
+        .replace(/`[^`]*`/g, " ") // drop inline code spans
+        .split(/[^a-z']+/)
+        .filter(Boolean);
+    for (const t of tokens) {
+        if (VERBS.has(t))
+            return true;
+    }
+    return false;
+}
+function isLinkOnly(text) {
+    const t = text.trim();
+    return URL_ONLY.test(t) || LINK_ONLY.test(t);
+}
+/**
+ * Score the 3 cues. Returns confidence or null (reject).
+ * - form: starts with an imperative/prohibitive head (or "No X").
+ * - context: is a bullet OR sits under a rule-ish heading.
+ * - shape: 15–300 chars, has a verb-ish token, not link-only, not a declaration.
+ */
+function gate(text, isBullet, underRuleHeading) {
+    const t = text.trim();
+    const form = FORM_HEAD.test(t);
+    const context = isBullet || underRuleHeading;
+    const shape = t.length >= 15 &&
+        t.length <= 300 &&
+        hasVerbish(t) &&
+        !isLinkOnly(t) &&
+        !DECLARATION.test(t);
+    const cues = (form ? 1 : 0) + (context ? 1 : 0) + (shape ? 1 : 0);
+    if (cues >= 3)
+        return "high";
+    if (cues === 2)
+        return "medium";
+    return null;
+}
+// --- Atomicity split -------------------------------------------------------
+/** Never split when an exception clause carries polarity/meaning. */
+const HAS_EXCEPT = /\bexcept\b/i;
+function trimSpan(src, span) {
+    let { start, end } = span;
+    while (start < end && /\s/.test(src[start]))
+        start++;
+    while (end > start && /\s/.test(src[end - 1]))
+        end--;
+    return { start, end };
+}
+/**
+ * Try to split a single-line bullet's content span on ';' or sentence
+ * boundaries. Returns the resulting spans ONLY IF there is >1 and every
+ * piece independently passes the gate; otherwise returns [whole].
+ */
+function atomize(src, contentSpan, isBullet, underRuleHeading) {
+    const whole = trimSpan(src, contentSpan);
+    const wholeText = src.slice(whole.start, whole.end);
+    if (HAS_EXCEPT.test(wholeText))
+        return [whole];
+    // Candidate cut points: ';' and sentence terminators followed by a capital.
+    const cuts = [];
+    for (let i = whole.start; i < whole.end; i++) {
+        const c = src[i];
+        if (c === ";") {
+            cuts.push(i + 1);
+        }
+        else if (c === "." || c === "!" || c === "?") {
+            // sentence boundary: terminator + whitespace + capital letter
+            const rest = src.slice(i + 1, whole.end);
+            const m = /^\s+[A-Z]/.exec(rest);
+            if (m)
+                cuts.push(i + 1);
+        }
+    }
+    if (cuts.length === 0)
+        return [whole];
+    const bounds = [whole.start, ...cuts, whole.end];
+    const pieces = [];
+    for (let i = 0; i < bounds.length - 1; i++) {
+        const piece = trimSpan(src, { start: bounds[i], end: bounds[i + 1] });
+        // strip a leading semicolon left by the cut
+        while (piece.start < piece.end &&
+            (src[piece.start] === ";" || /\s/.test(src[piece.start]))) {
+            piece.start++;
+        }
+        if (piece.start >= piece.end)
+            return [whole];
+        pieces.push(piece);
+    }
+    // Both/all halves must independently pass the gate, else keep whole.
+    for (const p of pieces) {
+        const text = normalize(src.slice(p.start, p.end));
+        if (gate(text, isBullet, underRuleHeading) === null)
+            return [whole];
+    }
+    return pieces.length > 1 ? pieces : [whole];
+}
+// --- Emission --------------------------------------------------------------
+function emitFromSpan(src, lineOffsets, file, span, confidence) {
+    const exactQuote = src.slice(span.start, span.end);
+    return {
+        text: normalize(exactQuote),
+        file,
+        lineStart: offsetToLine(lineOffsets, span.start),
+        lineEnd: offsetToLine(lineOffsets, span.end - 1),
+        exactQuote,
+        confidence,
+    };
+}
+// --- Scanner ---------------------------------------------------------------
+const LIST_ITEM = /^(\s*)([-*+])(\s+)(.*)$/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const FENCE = /^\s*(```|~~~)/;
+const TABLE_LINE = /^\s*\|/;
+/**
+ * Split a CLAUDE.md / AGENTS.md into atomic candidate rules with provenance.
+ *
+ * Deterministic Tier-A heuristic. Code fences and tables are excluded from
+ * candidacy. Candidate units are (a) list items with attached continuation
+ * lines and (b) sentences of paragraphs under a rule-ish heading.
+ */
+function segmentInstructions(markdown, file) {
+    const lines = markdown.split("\n");
+    const lineOffsets = computeLineOffsets(lines);
+    const out = [];
+    let inFence = false;
+    let currentHeadingIsRuleish = false;
+    let i = 0;
+    const lineSpan = (a, b) => ({
+        start: lineOffsets[a],
+        end: lineOffsets[b] + lines[b].length,
+    });
+    while (i < lines.length) {
+        const line = lines[i];
+        // Code fences: toggle and skip everything inside (incl. the fence lines).
+        if (FENCE.test(line)) {
+            inFence = !inFence;
+            i++;
+            continue;
+        }
+        if (inFence) {
+            i++;
+            continue;
+        }
+        // Headings: update rule-ish context, not a candidate.
+        const h = HEADING.exec(line);
+        if (h) {
+            currentHeadingIsRuleish = RULE_HEADING.test(h[2]);
+            i++;
+            continue;
+        }
+        // Tables: excluded from candidacy.
+        if (TABLE_LINE.test(line)) {
+            i++;
+            continue;
+        }
+        // List items (with attached continuation lines).
+        const li = LIST_ITEM.exec(line);
+        if (li) {
+            const markerIndent = li[1].length;
+            const contentCol = li[1].length + li[2].length + li[3].length;
+            const startLine = i;
+            // Gather continuation lines: deeper-indented, non-blank, not a new
+            // list marker, not a heading, not a fence.
+            let endLine = i;
+            let j = i + 1;
+            while (j < lines.length) {
+                const cand = lines[j];
+                if (cand.trim() === "")
+                    break;
+                if (FENCE.test(cand))
+                    break;
+                if (HEADING.test(cand))
+                    break;
+                const indent = cand.length - cand.trimStart().length;
+                if (indent <= markerIndent)
+                    break;
+                if (LIST_ITEM.test(cand))
+                    break; // nested/sibling bullet => separate candidate
+                endLine = j;
+                j++;
+            }
+            const multiLine = endLine > startLine;
+            const contentStart = lineOffsets[startLine] + contentCol;
+            const contentEnd = lineOffsets[endLine] + lines[endLine].length;
+            const contentSpan = { start: contentStart, end: contentEnd };
+            const wholeText = normalize(markdown.slice(contentStart, contentEnd));
+            const conf = gate(wholeText, true, currentHeadingIsRuleish);
+            if (conf !== null) {
+                // Only attempt splitting for single-line items (keeps offsets exact).
+                const spans = multiLine
+                    ? [trimSpan(markdown, contentSpan)]
+                    : atomize(markdown, contentSpan, true, currentHeadingIsRuleish);
+                if (spans.length === 1) {
+                    // Emit whole item; exactQuote is the full source span incl. marker.
+                    out.push(emitFromSpan(markdown, lineOffsets, file, lineSpan(startLine, endLine), conf));
+                }
+                else {
+                    for (const s of spans) {
+                        const text = normalize(markdown.slice(s.start, s.end));
+                        const c = gate(text, true, currentHeadingIsRuleish);
+                        if (c !== null)
+                            out.push(emitFromSpan(markdown, lineOffsets, file, s, c));
+                    }
+                }
+            }
+            i = endLine + 1;
+            continue;
+        }
+        // Paragraph block: accumulate until blank / heading / list / fence / table.
+        if (line.trim() !== "") {
+            const startLine = i;
+            let endLine = i;
+            let j = i + 1;
+            while (j < lines.length) {
+                const cand = lines[j];
+                if (cand.trim() === "")
+                    break;
+                if (FENCE.test(cand))
+                    break;
+                if (HEADING.test(cand))
+                    break;
+                if (LIST_ITEM.test(cand))
+                    break;
+                if (TABLE_LINE.test(cand))
+                    break;
+                endLine = j;
+                j++;
+            }
+            // Prose is only a candidate under a rule-ish heading.
+            if (currentHeadingIsRuleish) {
+                const paraStart = lineOffsets[startLine];
+                const paraEnd = lineOffsets[endLine] + lines[endLine].length;
+                const paraText = markdown.slice(paraStart, paraEnd);
+                // Sentence spans preserving absolute offsets.
+                const re = /[^.!?]+[.!?]+(\s|$)|[^.!?]+$/g;
+                let m;
+                while ((m = re.exec(paraText)) !== null) {
+                    const s = trimSpan(markdown, {
+                        start: paraStart + m.index,
+                        end: paraStart + m.index + m[0].length,
+                    });
+                    if (s.start >= s.end)
+                        continue;
+                    const text = normalize(markdown.slice(s.start, s.end));
+                    const c = gate(text, false, true);
+                    if (c !== null)
+                        out.push(emitFromSpan(markdown, lineOffsets, file, s, c));
+                }
+            }
+            i = endLine + 1;
+            continue;
+        }
+        i++;
+    }
+    return out;
+}
+//# sourceMappingURL=segment.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vigiles",
-  "version": "12.7.0",
+  "version": "13.0.0",
   "description": "Lint & test the harness your AI agent runs on — verify the references in your CLAUDE.md / AGENTS.md and test that your hooks and skills actually work.",
   "keywords": [
     "claude-code",