vigiles 13.0.0 → 14.0.0

package/dist/rule-routing.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.routeRules = routeRules;
+exports.mergeRoutings = mergeRoutings;
 /**
  * rule-routing.ts — the deterministic (no-model) State-B routing PREVIEW.
  *
@@ -11,18 +12,29 @@ exports.routeRules = routeRules;
  * 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.
+ *              → mechanism: flip one config line. The "narrow list we compile
+ *              very well" — everything else is honestly labelled, not force-fit.
  *   hook     → an ACTION rule a linter can't see (git push, rm -rf, "before you
  *              commit") → mechanism: a pre-commit / PreToolUse hook.
+ *   meta     → an agent-instruction, not a code rule ("read X first", "tell the
+ *              user", "you are …") → mechanism: stays prose. Split out of
+ *              `unrouted` so it never reads as "compilable but hard" (it isn't).
  *   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).
+ *   unrouted → looks like a code rule but matched no off-the-shelf rule: HARD to
+ *              codify → mechanism `synthesize`: the opt-in SYNTHESIS tier (a
+ *              skill on your subscription) MIGHT write a custom checker, gated —
+ *              but it is NOT guaranteed (the gate may abstain). This is the
+ *              bucket audit must present clearly as "hard", never as done.
+ *
+ * NB "compile" is NOT used here — `vigiles compile` is the unrelated spec→markdown
+ * verb. Synthesis is its own opt-in tier; the mechanism value is `synthesize`.
  *
  * 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.
+ * is exactly the work the opt-in model tier does. `unrouted` means "hard — a
+ * synthesis skill may try", never a promise; `meta`/`semantic` mean "not an
+ * enforceable code rule at all" (a different, honest kind of no).
  *
  * Pure, deterministic, dependency-free. Reuses `rule-inventory`'s hardened
  * whole-token matcher + `INTENT_MAP`, and `segment`'s Tier-A segmenter.
@@ -33,33 +45,66 @@ const rule_inventory_js_1 = require("./rule-inventory.js");
 const MECHANISM = {
     reuse: "config-line",
     hook: "hook",
+    meta: "prose",
     semantic: "prose",
-    unrouted: "compile",
+    unrouted: "synthesize",
 };
 /**
  * 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.
+ * process). A hook is the right gate, not a lint rule. Widened to the article's
+ * measured surfaces (vcs / process / shell / redirect) — the narrow original
+ * (git-push + rm-rf only) reported ~2% hooks where the 252-rule hand-sort found
+ * **37%** (the largest bucket); it was missing push-to-branch, before-push,
+ * after-edit, tool-substitution, amend/rebase-pushed, and dependency guards.
+ * See `research/rule-compiler-multilang-design.md` §5b (the hook lane).
  */
 const HOOK_CUES = [
+    // — branch / push guards (vcs) —
     /\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,
+    // "push … to main/master/prod/origin" — tolerate backticks/adverbs between.
+    /\bpush\w*\b[^.\n]{0,24}\b(main|master|prod|production|origin|development)\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,
+    /\bpush\w*\b[^.\n]{0,16}\bbranch/i,
+    // — protected paths (vcs) —
+    /\b(don'?t|do not|never)\s+(edit|modify|touch|change)\b[^.\n]{0,30}\b(generated|vendored|lock(file)?|\.pb\.|proto-gen|_mock|snapshot)/i,
+    /\bgenerated\s+files?\b/i,
+    // — sequencing / tests-before / after-edit (process) —
+    /\b(run|execute)\b[^.\n]{0,30}\b(tests?|lint|check|type-?check|format|prettier|ruff)\b[^.\n]{0,20}\bbefore\b/i,
+    /\bbefore\s+(you\s+|each\s+|every\s+)?(commit|push|merg|committing|pushing)/i,
     /\brun\b[^.\n]{0,20}\btests?\b[^.\n]{0,14}\bbefore\b/i,
+    /\b(format|lint|check|run)\b[^.\n]{0,30}\b(after|immediately after)\b[^.\n]{0,16}\b(writ|edit)/i,
+    // — tool substitution / redirect —
+    /\b(never|do not|don'?t)\s+run\b[^.\n]{0,30}\b(directly|instead)\b/i,
+    /\b(never|do not|don'?t)\s+run\b[^.\n]{0,20}`?(eslint|prettier|npm|npx|cargo|yarn|pnpm|pip|black|ruff)\b/i,
+    /\buse\b\s+`?[\w:.-]+`?\s+(instead of|not|over|rather than)\s+`?(npm|npx|cargo|yarn|pnpm|eslint|prettier)\b/i,
+    // — regenerate-on-change guard (vigiles's own guard() path→cmd shape: "run X
+    //   after/when Y changes") — the single biggest missed-hook pattern in the OSS
+    //   dogfood. Both clause orders; the trigger MUST be a change-verb so a benign
+    //   "run it when ready" doesn't match.
+    /\b(re-?run|regenerate|re-?generate|rebuild|regen|run|update)\b[^.\n]{0,48}\b(after|when|whenever|once|if)\b[^.\n]{0,24}\b(chang|add(?:ing|ed)?|modif|updat|edit|new\b)/i,
+    /\b(after|when|whenever|once)\b[^.\n]{0,24}\b(chang|add(?:ing|ed)?|modif|updat|edit)[^.\n]{0,48}\b(re-?run|regenerate|rebuild|regen|run|update)\b/i,
+    // — commit content / history (vcs) —
+    /\b(amend|squash|rebase)\b[^.\n]{0,40}\b(pushed|review|remote|shared)\b/i,
+    /--no-verify/i,
+    /\b(never|do not|don'?t)\s+commit\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,
+    /\bco-?author(?:s|ed|ing|ed-by)?\b/i,
+    // commit/PR METADATA hygiene phrased without a push verb (attribution, PR
+    // title, commit message, semantic/conventional commits) — a VCS-surface gate.
+    /\b(generated with|attribution)\b[^.\n]{0,24}\b(claude|ai|footer|commit|pr)\b/i,
+    /\b(ai|claude|assistant)\b[^.\n]{0,16}\battribution\b/i,
+    /\b(semantic|conventional)\s+(commit|pr|pull request)/i,
+    // NB: deliberately NO broad `(commit|pr) (title|message)` cue — it mislabels
+    // style sentences ("use sentence case for PR titles", "keep commit messages
+    // concise") as gates. The enforceable format/attribution rules are caught by
+    // the semantic/conventional + attribution cues above; the rest stay prose.
+    // — dependency / config guard —
+    /\b(never|do not|don'?t)\b[^.\n]{0,20}\bupdate\b[^.\n]{0,20}\b(depend|package\.json|lock)/i,
+    // — destructive / shell —
     /\brm\s+-rf\b/i,
     /\bcurl\b.*\|\s*(sh|bash)/i,
     /\bchmod\b/i,
+    /\bdestructive\s+git\b/i,
 ];
 /**
  * Judgment / no-checker cues — a rule no linter can honestly decide, so it stays
@@ -82,23 +127,231 @@ const SEMANTIC_CUES = [
     /\bbest practices?\b/i,
     /\bclean code\b/i,
 ];
+/**
+ * META cues — an instruction to the AGENT, not a norm about the CODE ("read X
+ * first", "tell the user", "you are …", "when in doubt ask"). It is not a lint
+ * rule and never will be, so it must NOT land in `unrouted` (which reads as
+ * "compilable, just hard"). High-precision by design — specific phrasings a real
+ * code rule would not use.
+ */
+const META_CUES = [
+    // allow `.` in the gap — the referenced thing is often a filename (CLAUDE.md)
+    /\bread\b[^\n]{0,30}\bfirst\b/i,
+    /\bwhen in doubt\b/i,
+    /\bif (you'?re |you are )?unsure\b/i,
+    /\bask (the user|first|before)\b/i,
+    /\btell (the user|me)\b/i,
+    /\byou are\b[^.\n]{0,40}\b(assistant|agent|engineer|claude|model)\b/i,
+    /\byour (job|task|role) is\b/i,
+    /\b(do not|don'?t|never) (tell|mention|reveal|say)\b/i,
+    /\bin (chat|your (reply|response|answer))\b/i,
+    // H5 agent-ATTENTION norms (Fable's hook-lane taxonomy): re-read / re-run /
+    // re-fetch "without code changes". NOTHING reliably gates these — blocking a
+    // re-read breaks post-compaction recovery (false safety worse than an
+    // under-blocking guard) — so they are agent-guidance (meta), never a gate. The
+    // right instrument is MEASUREMENT (the flight recorder), not enforcement.
+    /\bre-?read(?:ing)?\b/i,
+    /\bre-?run(?:ning)?\b[^\n]{0,30}\b(?:test|command|suite)\b/i,
+    /\bre-?fetch(?:ing)?\b/i,
+    /\bwithout code changes\b/i,
+];
+const PATTERN_RULE_MAP = [
+    {
+        construct: "default exports",
+        rule: "no-restricted-syntax",
+        linter: "eslint",
+        pattern: /\b(?:no|never|avoid|don'?t\s+use|do\s+not\s+use|disallow|ban|forbid|prefer\s+named\s+(?:exports?\s+)?over)\b[^.\n]{0,24}\bdefault\s+exports?\b/i,
+        configFix: '"no-restricted-syntax": ["error", { "selector": "ExportDefaultDeclaration", "message": "Use named exports." }]',
+    },
+    {
+        construct: "enums",
+        rule: "no-restricted-syntax",
+        linter: "eslint",
+        pattern: /\b(?:no|never|avoid|don'?t\s+use|do\s+not\s+use|disallow|ban|forbid)\b[^.\n]{0,24}\benums?\b/i,
+        configFix: '"no-restricted-syntax": ["error", { "selector": "TSEnumDeclaration", "message": "Use a union or const object instead of an enum." }]',
+    },
+    {
+        construct: "for...in",
+        rule: "no-restricted-syntax",
+        linter: "eslint",
+        pattern: /\b(?:no|never|avoid|don'?t\s+use|do\s+not\s+use|disallow|ban|forbid)\b[^.\n]{0,16}\bfor[\s.]{0,3}in\b/i,
+        configFix: '"no-restricted-syntax": ["error", { "selector": "ForInStatement", "message": "Use for...of or Object.keys()." }]',
+    },
+    {
+        construct: "namespaces",
+        rule: "no-restricted-syntax",
+        linter: "eslint",
+        pattern: /\b(?:no|never|avoid|don'?t\s+use|do\s+not\s+use|disallow|ban|forbid)\b[^.\n]{0,24}\bnamespaces?\b/i,
+        configFix: '"no-restricted-syntax": ["error", { "selector": "TSModuleDeclaration", "message": "Use ES modules instead of namespaces." }]',
+    },
+    {
+        construct: "classes",
+        rule: "no-restricted-syntax",
+        linter: "eslint",
+        pattern: /\b(?:no|never|avoid|don'?t\s+use|do\s+not\s+use|disallow|ban|forbid)\b[^.\n]{0,12}\b(?<!css |style |styling |utility |tailwind |dom |react |component )(?:es6?\s+|javascript\s+)?class(?:es)?\b(?![\s-]*(?:name|attribute|selector|list))/i,
+        configFix: '"no-restricted-syntax": ["error", { "selector": ":matches(ClassDeclaration, ClassExpression)", "message": "Prefer functions and closures over classes." }]',
+    },
+    // Pylint: REQUIRE docstrings → missing-function-docstring. A PRESENCE context is
+    // required (a presence verb near "docstring", or "docstrings required/for each")
+    // so a bare "docstring" mention does NOT over-fire: the dogfood caught langchain
+    // routing docstring-CONTENT/STYLE rules ("docstring warnings", "backticks in
+    // docstrings", "don't repeat the default in the docstring") to this presence
+    // check — those are pydocstyle/ruff-D territory, not missing-docstring.
+    {
+        construct: "docstrings (presence)",
+        rule: "missing-function-docstring",
+        linter: "pylint",
+        pattern: /\b(?:add|require|requires?|write|writing|include|need|needs?|use|using|provide|document|must\s+have)\b[^.\n]{0,24}\bdocstrings?\b|\bdocstrings?\b[^.\n]{0,24}\b(?:required|mandatory|for\s+(?:all|every|each|every|public)|on\s+(?:all|every|each))\b/i,
+        configFix: "pylint enables missing-function-docstring (C0116) by default; keep it out of the disable list",
+    },
+];
+/**
+ * Backticked rule-id-shaped tokens a bullet names — `curly`, `curly: error` →
+ * `curly`, `@typescript-eslint/consistent-type-imports`, `no-only-tests/no-only-tests`.
+ * The leading id is taken (severity/args after a `:`/space are dropped), so the
+ * token can be looked up against the dynamic catalog.
+ */
+const CODE_SPAN_RE = /`([^`]+)`/g;
+function namedRuleTokens(text) {
+    const out = [];
+    for (const m of text.matchAll(CODE_SPAN_RE)) {
+        const id = m[1].trim().match(/^@?[a-z][\w-]*(?:\/[a-z][\w-]*)*/i);
+        if (id)
+            out.push(id[0]);
+    }
+    return out;
+}
 /**
  * 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.
+ * rule-name mention ("never commit console.log" is a hook, not a lint rule); a
+ * META agent-instruction is pulled out before reuse so it isn't mismatched to a
+ * rule; the DYNAMIC catalog (if present) and the static `INTENT_MAP` both feed
+ * `reuse`; reuse wins over a soft semantic cue.
  */
-function classify(text) {
+function classify(text, catalog) {
     if (HOOK_CUES.some((re) => re.test(text)))
         return { category: "hook" };
+    if (META_CUES.some((re) => re.test(text)))
+        return { category: "meta" };
+    // Dynamic catalog: a bullet that NAMES one of the repo's real rules → reuse,
+    // carrying whether it's currently enabled (a disabled hit = the "documented but
+    // OFF" nudge). Own-repo only — catalog is present only when the linter was
+    // enumerated with consent.
+    if (catalog) {
+        for (const tok of namedRuleTokens(text)) {
+            const enabled = catalog.get(tok);
+            if (enabled !== undefined)
+                return { category: "reuse", rule: tok, enabled };
+        }
+    }
     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 };
         }
     }
+    // Pattern → a built-in parameterized rule (eslint no-restricted-syntax
+    // construct-prohibitions; pylint docstring-presence). These LOOK custom but
+    // are reuse; each carries its own linter.
+    for (const r of PATTERN_RULE_MAP) {
+        if (r.pattern.test(text))
+            return { category: "reuse", rule: r.rule, linter: r.linter };
+    }
     if (SEMANTIC_CUES.some((re) => re.test(text)))
         return { category: "semantic" };
     return { category: "unrouted" };
 }
+// --- Structured-marker pre-pass (S0/S1) ------------------------------------
+const ENFORCED_RE = /^\*\*Enforced by:\*\*\s*`([^`]+)`/;
+const GUARD_RE = /^\*\*Guard:\*\*/;
+const GUIDANCE_RE = /^\*\*Guidance only\*\*/;
+const MARK_HEADING = /^(#{2,6})\s+(.*)$/;
+const RULE_ID_SHAPE = /^@?[a-z][a-z0-9._/-]*$/;
+/** Does this `**Enforced by:**` value parse as a lint-rule id (vs a prose claim
+ * like "CI" or "the linter")? A hand-written marker is a CLAIM — only a rule-id
+ * shape is treated as a real reuse rule. */
+function looksLikeRuleId(s) {
+    return s.length >= 3 && RULE_ID_SHAPE.test(s.trim());
+}
+/**
+ * Extract rules from EXPLICIT structured markers (`**Enforced by:** \`rule\``,
+ * `**Guard:**`, `**Guidance only**`) — the S0/S1 tier. A compiled/marked doc
+ * declares its own routing, so these are definitive (zero-heuristic) and are
+ * CONSUMED before the heuristic segmenter runs (the returned `skip` line set) so
+ * a marked rule is never double-counted. Each marker → ONE atom named by its
+ * `##`/`###` heading; a `**Guidance only**` body is still routed through
+ * `classify` (the promote-prose signal: a guidance whose body says "before
+ * commit" surfaces as a would-be hook). Foreign hand-written `**Enforced by:**`
+ * is a CLAIM — only a rule-id-shaped value becomes a reuse rule (gated + verified
+ * against the catalog when present; never an inferred contradiction).
+ */
+function extractMarkedRules(text, file, catalog) {
+    const lines = text.split("\n");
+    const rules = [];
+    const skip = new Set();
+    for (let i = 0; i < lines.length; i++) {
+        const h = MARK_HEADING.exec(lines[i]);
+        if (!h)
+            continue;
+        let j = i + 1;
+        while (j < lines.length && !MARK_HEADING.test(lines[j]))
+            j++;
+        const section = lines.slice(i, j); // [heading … next-heading)
+        const heading = h[2].trim();
+        let marked = null;
+        for (const raw of section.slice(1)) {
+            const bl = raw.trim();
+            const em = ENFORCED_RE.exec(bl);
+            if (em) {
+                if (!looksLikeRuleId(em[1]))
+                    break; // a prose claim, not a rule id
+                const enabled = catalog?.get(em[1].trim());
+                marked = {
+                    category: "reuse",
+                    rule: em[1].trim(),
+                    ...(enabled !== undefined ? { enabled } : {}),
+                };
+                break;
+            }
+            if (GUARD_RE.test(bl)) {
+                marked = { category: "hook" };
+                break;
+            }
+            if (GUIDANCE_RE.test(bl)) {
+                // Route the guidance BODY through classify (promote-prose): a guidance
+                // whose text is really an action shows up as a would-be hook.
+                const body = section.slice(1).join(" ");
+                const c = classify(body, catalog);
+                // A guidance body that names a catalog rule is still "documented as
+                // guidance" — keep it prose unless it's a genuine action/agent cue.
+                marked =
+                    c.category === "hook" || c.category === "meta"
+                        ? c
+                        : { category: "semantic" };
+                break;
+            }
+        }
+        if (!marked)
+            continue;
+        // Consume the section BODY lines (heading stays a non-candidate) so the
+        // heuristic segmenter never re-emits this marked rule. (1-based.)
+        for (let k = i + 1; k < j; k++)
+            skip.add(k + 1);
+        rules.push({
+            text: heading,
+            quote: lines[i],
+            file,
+            lineStart: i + 1,
+            lineEnd: j,
+            confidence: "high",
+            category: marked.category,
+            mechanism: MECHANISM[marked.category],
+            source: "marker",
+            ...(marked.rule ? { rule: marked.rule } : {}),
+            ...(marked.enabled !== undefined ? { enabled: marked.enabled } : {}),
+        });
+    }
+    return { rules, skip };
+}
 /**
  * Segment the instruction file and route every atomic rule deterministically.
  * Pure: the caller passes the concatenated instruction text (and an optional
@@ -106,9 +359,38 @@ function classify(text) {
  */
 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);
+    const catalog = options.availableRules
+        ? new Map(options.availableRules.rules.map((r) => [r.id, r.enabled]))
+        : undefined;
+    // A MEDIUM segment that NAMES a rule the repo's catalog actually has is
+    // enforceable — the catalog is ground truth, so it's higher-precision than the
+    // segmenter's imperative-head cue. This rescues declarative-subject bullets
+    // ("The core layer must not import X (`boundaries/dependencies`)") that score
+    // medium (context+shape, no imperative head) and are otherwise dropped by the
+    // high-only default. Own-repo only (catalog present ⇒ enumerated with consent);
+    // the foreign-safe textual path stays conservative by design.
+    const namesCatalogRule = (text) => catalog !== undefined &&
+        namedRuleTokens(text).some((tok) => catalog.has(tok));
+    // A MEDIUM segment matching a construct-prohibition ("No default exports")
+    // scores medium ("No" is a prohibition head, not a verb) but is a real reuse
+    // rule (no-restricted-syntax) — rescue it, same as the catalog rescue. The
+    // patterns are their own precision gate (prohibition + construct proximity).
+    const matchesPatternRule = (text) => PATTERN_RULE_MAP.some((r) => r.pattern.test(text));
+    // A MEDIUM segment that matches an INTENT_MAP keyword (code-shaped, high-
+    // precision) is a real reuse rule — rescue it, same as catalog/restricted-
+    // syntax. Fixes construct-prohibitions with no verb ("No bare except clauses")
+    // that score medium and would otherwise drop before classify() reuses them.
+    const matchesIntentMap = (text) => rule_inventory_js_1.INTENT_MAP.some((m) => m.keywords.some((kw) => (0, rule_inventory_js_1.matchesWholeToken)(text, kw)));
+    // S0/S1 pre-pass: explicit markers are definitive and are CONSUMED (their body
+    // lines are skipped) so the heuristic segmenter can't double-count them.
+    const marked = extractMarkedRules(instructionText, file, catalog);
+    const segments = (0, segment_js_1.segmentInstructions)(instructionText, file, marked.skip).filter((s) => minConfidence === "medium" ||
+        s.confidence === "high" ||
+        namesCatalogRule(s.text) ||
+        matchesPatternRule(s.text) ||
+        matchesIntentMap(s.text));
+    const heuristicRules = segments.map((s) => {
+        const c = classify(s.text, catalog);
         return {
             text: s.text,
             quote: s.exactQuote,
@@ -118,18 +400,47 @@ function routeRules(instructionText, file, options = {}) {
             confidence: s.confidence,
             category: c.category,
             mechanism: MECHANISM[c.category],
+            source: "heuristic",
             ...(c.rule ? { rule: c.rule } : {}),
             ...(c.linter ? { linter: c.linter } : {}),
+            ...(c.enabled !== undefined ? { enabled: c.enabled } : {}),
         };
     });
+    // Marker rules first (definitive), then the heuristic residue.
+    const rules = [...marked.rules, ...heuristicRules];
     const counts = {
         reuse: 0,
         hook: 0,
+        meta: 0,
         semantic: 0,
         unrouted: 0,
     };
     for (const r of rules)
         counts[r.category]++;
-    return { segmented: segments.length, counts, rules };
+    return { segmented: rules.length, counts, rules };
+}
+/**
+ * Merge per-file routings into one. Each instruction source is routed SEPARATELY
+ * (so every rule keeps its OWN file path + line numbers — concatenating first
+ * would corrupt the provenance the preview promises), then folded here: rules
+ * concatenated, counts + segmented summed. Pure. `[]` → an empty routing.
+ */
+function mergeRoutings(routings) {
+    const counts = {
+        reuse: 0,
+        hook: 0,
+        meta: 0,
+        semantic: 0,
+        unrouted: 0,
+    };
+    const rules = [];
+    let segmented = 0;
+    for (const r of routings) {
+        segmented += r.segmented;
+        rules.push(...r.rules);
+        for (const k of Object.keys(counts))
+            counts[k] += r.counts[k];
+    }
+    return { segmented, counts, rules };
 }
 //# sourceMappingURL=rule-routing.js.map

package/dist/segment.d.ts

@@ -29,5 +29,5 @@ export interface SegmentedRule {
  * 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[];
+export declare function segmentInstructions(markdown: string, file?: string, skipLines?: ReadonlySet<number>): SegmentedRule[];
 //# sourceMappingURL=segment.d.ts.map