@rigour-labs/core 6.11.0 → 6.11.1-rc.2

package/dist/gates/logic-drift-git-base.d.ts

@@ -1,4 +1,7 @@
 export interface GitLogicBase {
+    /** The commit compared against. */
+    base: string;
+    /** Tracked files that differ from the base (added, copied, modified, renamed). Untracked files are not in it. */
     changedFiles: Set<string>;
     readAtBase: (file: string) => string | null;
 }
@@ -14,3 +17,9 @@ export interface BranchBase {
 export declare function branchBase(cwd: string): BranchBase | null;
 /** Use a fixed commit for the entire scan; never move the baseline on read. */
 export declare function resolveGitLogicBase(cwd: string): GitLogicBase | null;
+/** Files git does not track and does not ignore: what an agent just created. */
+export declare function untrackedFiles(cwd: string): string[];
+/** Every file committed at `commit`, repository-relative with `/`. */
+export declare function filesAtCommit(cwd: string, commit: string): string[];
+/** The contents of `files` at `commit`, read by one git process; a file missing there is left out. */
+export declare function readManyAtCommit(cwd: string, commit: string, files: string[]): Map<string, string>;

package/dist/gates/logic-drift-git-base.js

@@ -40,7 +40,43 @@ export function resolveGitLogicBase(cwd) {
     if (diff === null)
         return null;
     return {
+        base,
         changedFiles: new Set(diff.split('\0').filter(Boolean)),
         readAtBase: file => git(cwd, ['show', `${base}:${file}`]),
     };
 }
+/** Files git does not track and does not ignore: what an agent just created. */
+export function untrackedFiles(cwd) {
+    return (git(cwd, ['ls-files', '--others', '--exclude-standard', '-z']) ?? '').split('\0').filter(Boolean);
+}
+/** Every file committed at `commit`, repository-relative with `/`. */
+export function filesAtCommit(cwd, commit) {
+    return (git(cwd, ['ls-tree', '-r', '--name-only', '-z', commit]) ?? '').split('\0').filter(Boolean);
+}
+/** The contents of `files` at `commit`, read by one git process; a file missing there is left out. */
+export function readManyAtCommit(cwd, commit, files) {
+    const contents = new Map();
+    if (files.length === 0)
+        return contents;
+    let out;
+    try {
+        out = execFileSync('git', ['cat-file', '--batch'], { cwd, input: files.map(file => `${commit}:${file}`).join('\n') + '\n', stdio: ['pipe', 'pipe', 'ignore'], maxBuffer: 256 * 1024 * 1024 });
+    }
+    catch {
+        return contents;
+    }
+    let at = 0;
+    for (const file of files) {
+        const end = out.indexOf(0x0a, at);
+        if (end < 0)
+            break;
+        const header = out.subarray(at, end).toString('utf8').split(' ');
+        at = end + 1;
+        if (header[1] !== 'blob')
+            continue; // "<name> missing", or not a file
+        const size = Number(header[2]);
+        contents.set(file, out.subarray(at, at + size).toString('utf8'));
+        at += size + 1;
+    }
+    return contents;
+}

package/dist/gates/style-drift.d.ts

@@ -32,8 +32,16 @@ export declare class StyleDriftGate extends Gate {
     constructor(config?: StyleDriftConfig);
     protected get provenance(): Provenance;
     run(context: GateContext): Promise<Failure[]>;
+    /**
+     * The changed and untracked files, each against a fingerprint of its language's files committed at the base.
+     * On the base branch with a clean tree nothing differs, so nothing is compared.
+     */
+    private againstGitBase;
+    /** Each file against its own language's fingerprint. */
+    private compare;
     private computePerLanguageBaseline;
     private computeFingerprint;
+    private fingerprintOf;
     private emptyFingerprint;
     private analyzeFile;
     private mergeIntoFingerprint;

package/dist/gates/style-drift.js

@@ -25,6 +25,7 @@ import { Logger } from '../utils/logger.js';
 import { languageAdapters } from './language-adapters/index.js';
 import { extractComparableJsNames } from './js-style-context.js';
 import { isScoped } from '../utils/scope.js';
+import { filesAtCommit, isGitWorktree, readManyAtCommit, resolveGitLogicBase, untrackedFiles } from './logic-drift-git-base.js';
 import { TRY_CATCH_PATTERN, CATCH_PATTERN, RESULT_TYPE_PATTERN, NAMED_IMPORT_PATTERN, WILDCARD_IMPORT_PATTERN, SIDE_EFFECT_IMPORT_PATTERN, DEFAULT_IMPORT_PATTERN, countQuotes, } from './style-drift-rules.js';
 import fs from 'fs-extra';
 import path from 'path';
@@ -43,16 +44,26 @@ export class StyleDriftGate extends Gate {
     async run(context) {
         if (!this.config.enabled)
             return [];
-        const failures = [];
         const baselinePath = path.join(context.cwd, this.config.baseline_path);
         // Find source files
+        const ignore = [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*', '**/*.d.ts'];
         const files = await FileScanner.findFiles({
             cwd: context.cwd,
             patterns: context.patterns || languageAdapters.getScanPatterns(),
-            ignore: [...(context.ignore || []), '**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*', '**/*.d.ts'],
+            ignore,
         });
         if (files.length === 0)
             return [];
+        // In a git checkout the project's style is the code committed at the base, read fresh on every run, and
+        // only the files that differ from it are compared. Nothing is cached, so no earlier run on a dirty tree
+        // can change a verdict, and a .rigour/style-baseline.json left by an older version is never read.
+        const gitBase = resolveGitLogicBase(context.cwd);
+        if (!gitBase && isGitWorktree(context.cwd)) {
+            Logger.info('Style Drift: no main reference available; comparison unavailable');
+            return [];
+        }
+        if (gitBase)
+            return this.againstGitBase(context, files, ignore, gitBase);
         // Group files by language
         const filesByLang = new Map();
         for (const file of files) {
@@ -94,6 +105,38 @@ export class StyleDriftGate extends Gate {
             return []; // No failures on first scan
         }
         // Subsequent scan: compare each file against its own language's baseline
+        return this.compare(context, files, baseline);
+    }
+    /**
+     * The changed and untracked files, each against a fingerprint of its language's files committed at the base.
+     * On the base branch with a clean tree nothing differs, so nothing is compared.
+     */
+    async againstGitBase(context, files, ignore, gitBase) {
+        const changed = new Set([...gitBase.changedFiles, ...untrackedFiles(context.cwd)]);
+        const compared = files.filter(file => changed.has(file));
+        if (compared.length === 0)
+            return [];
+        const languages = new Set(compared.map(file => languageAdapters.getAdapter(file)?.id));
+        const sampled = new Map();
+        for (const file of FileScanner.filterPaths(filesAtCommit(context.cwd, gitBase.base), { patterns: languageAdapters.getScanPatterns(), ignore })) {
+            const id = languageAdapters.getAdapter(file)?.id;
+            if (!id || !languages.has(id))
+                continue;
+            const list = sampled.get(id) ?? [];
+            if (list.length < this.config.sample_size)
+                list.push(file);
+            sampled.set(id, list);
+        }
+        const atBase = readManyAtCommit(context.cwd, gitBase.base, [...sampled.values()].flat());
+        const baseline = { languages: {}, createdAt: '', version: 3 };
+        for (const [id, list] of sampled) {
+            baseline.languages[id] = this.fingerprintOf(new Map(list.flatMap(file => atBase.has(file) ? [[file, atBase.get(file)]] : [])));
+        }
+        return this.compare(context, compared, baseline);
+    }
+    /** Each file against its own language's fingerprint. */
+    async compare(context, files, baseline) {
+        const failures = [];
         const contents = await FileScanner.readFiles(context.cwd, files, context.fileCache);
         for (const [file, content] of contents) {
             const adapter = languageAdapters.getAdapter(file);
@@ -132,8 +175,10 @@ export class StyleDriftGate extends Gate {
         return baseline;
     }
     async computeFingerprint(context, files) {
+        return this.fingerprintOf(await FileScanner.readFiles(context.cwd, files, context.fileCache));
+    }
+    fingerprintOf(contents) {
         const fingerprint = this.emptyFingerprint();
-        const contents = await FileScanner.readFiles(context.cwd, files, context.fileCache);
         for (const [file, content] of contents) {
             const fileAnalysis = this.analyzeFile(content, file);
             this.mergeIntoFingerprint(fingerprint, fileAnalysis);

package/dist/index.d.ts

@@ -49,7 +49,7 @@ export { decideCompiledCheck, proposeCompiledChecks, readCompiledChecks, suspens
 export { ruleWriterFor } from './review/reviewer/rule-writer.js';
 export { backtestLast, formatLast, scoreLast, LAST_LEDGER_PATH, type LastReport } from './review/backtest-last.js';
 export { buildRecord, recordLines, recordIntact, type ReviewRecord } from './review/reviewer/record.js';
-export { readLessons, writeLessons, decideLesson, lessonState, pendingDecision, matchLessons, lessonText, lessonsPath, type ReviewLesson, type LessonEvidence } from './review-learning/lessons.js';
+export { readLessons, writeLessons, decideLesson, acceptSuggestedText, lessonState, pendingDecision, matchLessons, lessonText, lessonsPath, type ReviewLesson, type LessonEvidence } from './review-learning/lessons.js';
 export { lessonsForDiff, lessonsSection, type LessonMode } from './review-learning/team-lessons.js';
 export { recordAgentWrites, captureHumanEdits } from './review-learning/human-edits.js';
 export { readRepoRules, rulesForDiff, rulesSection, splitRules, type RepoRule } from './review-learning/repo-rules.js';

package/dist/index.js

@@ -47,7 +47,7 @@ export { decideCompiledCheck, proposeCompiledChecks, readCompiledChecks, suspens
 export { ruleWriterFor } from './review/reviewer/rule-writer.js';
 export { backtestLast, formatLast, scoreLast, LAST_LEDGER_PATH } from './review/backtest-last.js';
 export { buildRecord, recordLines, recordIntact } from './review/reviewer/record.js';
-export { readLessons, writeLessons, decideLesson, lessonState, pendingDecision, matchLessons, lessonText, lessonsPath } from './review-learning/lessons.js';
+export { readLessons, writeLessons, decideLesson, acceptSuggestedText, lessonState, pendingDecision, matchLessons, lessonText, lessonsPath } from './review-learning/lessons.js';
 export { lessonsForDiff, lessonsSection } from './review-learning/team-lessons.js';
 export { recordAgentWrites, captureHumanEdits } from './review-learning/human-edits.js';
 export { readRepoRules, rulesForDiff, rulesSection, splitRules } from './review-learning/repo-rules.js';

package/dist/review-learning/learn-from-reviews.js

@@ -39,8 +39,9 @@ export async function learnFromReviews(cwd, options) {
     }
     const known = new Set(readLessons(cwd).flatMap(l => l.evidence.map(e => e.comment)));
     const points = lessons.flatMap(l => l.evidence).filter(e => e.kind === 'point' && !known.has(e.comment));
-    const fresh = lessons.filter(l => !l.evidence.every(e => known.has(e.comment)));
-    const merged = mergeLessons(readLessons(cwd), fresh);
+    // Comments read before go through too: each lands on its own lesson (mergeLessons matches the comment), which
+    // takes the text this version derives from it. Nothing is added twice.
+    const merged = mergeLessons(readLessons(cwd), lessons);
     // Outcomes accrue after the merge: every candidate whose pull request was read this run is checked again.
     if (options.mainRef) {
         const byNumber = new Map(prs.filter(pr => pr.mergedAt).map(pr => [pr.number, pr]));

package/dist/review-learning/lessons.d.ts

@@ -18,7 +18,7 @@ import type { Git, ReviewBody, ReviewComment } from './acted-on.js';
  *             until a person promotes it.
  * A record from before evidence kinds has none: it is a `point`.
  */
-export type EvidenceKind = 'point' | 'outcome' | 'counter' | 'correction' | 'accepted' | 'rejected' | 'norule' | 'followup' | 'lines' | 'dismissed' | 'against' | 'demoted' | 'reclassified' | 'compiled';
+export type EvidenceKind = 'point' | 'outcome' | 'counter' | 'correction' | 'accepted' | 'rejected' | 'norule' | 'followup' | 'lines' | 'dismissed' | 'against' | 'demoted' | 'reclassified' | 'compiled' | 'reworded';
 export interface LessonEvidence {
     kind?: EvidenceKind;
     pr: number;
@@ -50,6 +50,13 @@ export interface ReviewLesson {
     /** Which evidence made it a lesson. */
     promotedBy?: 'outcome' | 'correction' | 'person' | 'recurrence' | 'legacy';
     evidence: LessonEvidence[];
+    /**
+     * A corrected wording a newer version derived from the lesson's own comment, waiting for a person. A lesson
+     * a person decided keeps the wording they decided on until they take this one (acceptSuggestedText).
+     */
+    suggestedText?: string;
+    /** Why there is a suggestion: `parser fix`, a newer version reading the comment better. */
+    suggestedWhy?: string;
     /** Where the point sits in the commit it was made on, for outcome evidence (inline comments only). */
     at?: {
         commit: string;
@@ -65,7 +72,10 @@ export interface ReviewLesson {
  * evidence, never a promotion. A record from before evidence kinds keeps the state it had.
  */
 export declare function lessonState(lesson: ReviewLesson): Pick<ReviewLesson, 'state' | 'promotedBy'>;
-/** The point of a review comment: its bold title, else its first sentence, without tool output or markup. */
+/**
+ * The point of a review comment: its bold title, else its first sentence and, when that only says what is
+ * wrong, the first later sentence that says what to do. Without tool output or markup.
+ */
 export declare function lessonText(body: string): string;
 /** Identifiers a lesson is about: those the comment names, then those on the lines it pointed at. */
 export declare function lessonSymbols(body: string, codeLines: string[]): string[];
@@ -78,8 +88,8 @@ export declare function lessonFromComment(git: Git, comment: ReviewComment, at?:
  */
 export declare function lessonsFromReview(review: ReviewBody, changedAfter: string[], at?: string): ReviewLesson[];
 /**
- * Add lessons to the store. The same lesson again (same text, or the same
- * file with two shared symbols) adds evidence; acted on in enough PRs, it is
+ * Add lessons to the store. The same lesson again (isSameLesson: the same text, the same review
+ * comment, or the same file with two shared symbols) adds evidence; acted on in enough PRs, it is
  * verified.
  */
 export declare function mergeLessons(existing: ReviewLesson[], incoming: ReviewLesson[]): {
@@ -118,6 +128,8 @@ export declare function pendingDecision(lesson: ReviewLesson): LessonEvidence |
 export declare function writeLessons(cwd: string, lessons: ReviewLesson[]): void;
 /** A person's decision on a lesson, kept as evidence: accepted makes it a lesson, rejected an anti-lesson. Undefined for an unknown id. */
 export declare function decideLesson(cwd: string, id: string, decision: 'accepted' | 'rejected' | 'dismissed', by: string, why?: string): ReviewLesson | undefined;
+/** A person takes a decided lesson's suggested wording; who and the wording it replaced are kept as evidence. */
+export declare function acceptSuggestedText(cwd: string, id: string, by: string): ReviewLesson | undefined;
 /** An identifier specific enough to link two pieces of code: camelCase, snake_case, or long. */
 export declare function isSpecific(symbol: string): boolean;
 /** The meaningful words of a text or an identifier: `hasLaterAttempt` and "a later attempt" share later and attempt. */

package/dist/review-learning/lessons.js

@@ -15,7 +15,7 @@
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
-import { bodyPoints } from './review-points.js';
+import { bodyPoints, withoutEmphasis } from './review-points.js';
 const STORE = path.join('.rigour', 'review-lessons.json');
 const MAX_TEXT = 220;
 const MAX_SYMBOLS = 8;
@@ -69,7 +69,12 @@ export function lessonState(lesson) {
     const independent = reviewers >= 2 || wordings >= 2;
     return prs >= RECUR_PRS && authors >= RECUR_AUTHORS && independent ? { state: 'verified', promotedBy: 'recurrence' } : { state: 'candidate' };
 }
-/** The point of a review comment: its bold title, else its first sentence, without tool output or markup. */
+/** A sentence that tells the author what to do, not only what is wrong. */
+const INSTRUCTION = /^(?:please\s+)?(?:use|pick|avoid|don'?t|do not|never|always|make|keep|move|read|filter|check|change|drop|add|remove|pass|split|prefer|replace|rename|derive|select|return|validate|extract|bound|lock)\b|\b(?:should|must|instead)\b/i;
+/**
+ * The point of a review comment: its bold title, else its first sentence and, when that only says what is
+ * wrong, the first later sentence that says what to do. Without tool output or markup.
+ */
 export function lessonText(body) {
     const cleaned = body
         .replace(/<!--[\s\S]*?-->/g, '')
@@ -80,8 +85,10 @@ export function lessonText(body) {
         .filter(line => !/^\s*#*\s*\**\s*(low|medium|high|critical)\s+severity\s*\**\s*$/i.test(line))
         .join('\n');
     const bold = /\*\*(.+?)\*\*/.exec(cleaned)?.[1]?.trim();
-    const text = bold || cleaned.replace(/\s+/g, ' ').trim().split(/(?<=[.!?])\s/)[0] || '';
-    return pointText(text.replace(/[*_]/g, '')).slice(0, MAX_TEXT).trim();
+    const sentences = cleaned.replace(/\s+/g, ' ').trim().split(/(?<=[.!?])\s/);
+    const instruction = INSTRUCTION.test(sentences[0] ?? '') ? undefined : sentences.slice(1).find(s => INSTRUCTION.test(s));
+    const text = bold || [sentences[0] ?? '', instruction ?? ''].filter(Boolean).join(' ');
+    return pointText(withoutEmphasis(text)).slice(0, MAX_TEXT).trim();
 }
 /**
  * A point's words without a review bot's scaffolding (`In src/a.ts around lines 10-12:`), or '' when
@@ -130,7 +137,7 @@ export function lessonFromComment(git, comment, at = new Date().toISOString()) {
  */
 export function lessonsFromReview(review, changedAfter, at = new Date().toISOString()) {
     return bodyPoints(review.body).flatMap((point, i) => {
-        const text = pointText(point.replace(/[*_]/g, '')).slice(0, MAX_TEXT).trim();
+        const text = pointText(withoutEmphasis(point)).slice(0, MAX_TEXT).trim();
         if (text.length < 12)
             return [];
         const named = /(?:^|[\s`(])((?:[\w.-]+\/)+[\w.-]+\.\w+)/.exec(point)?.[1];
@@ -143,18 +150,15 @@ export function lessonsFromReview(review, changedAfter, at = new Date().toISOStr
     });
 }
 /**
- * Add lessons to the store. The same lesson again (same text, or the same
- * file with two shared symbols) adds evidence; acted on in enough PRs, it is
+ * Add lessons to the store. The same lesson again (isSameLesson: the same text, the same review
+ * comment, or the same file with two shared symbols) adds evidence; acted on in enough PRs, it is
  * verified.
  */
 export function mergeLessons(existing, incoming) {
     const lessons = existing.map(l => ({ ...l, evidence: [...l.evidence] }));
     let added = 0;
     for (const lesson of incoming) {
-        // Shared names find the same point made again on another pull request; two points on one pull request are two points.
-        const otherPr = (l) => !l.evidence.some(e => lesson.evidence.some(x => x.pr === e.pr));
-        const same = lessons.find(l => l.id === lesson.id || (l.file === lesson.file && shared(l.symbols, lesson.symbols) >= 2 && otherPr(l))
-            || (!l.file && !lesson.file && sameWords(l.text, lesson.text)));
+        const same = lessons.find(l => isSameLesson(l, lesson));
         if (!same) {
             lessons.push({ ...lesson, evidence: [...lesson.evidence] });
             added++;
@@ -163,6 +167,7 @@ export function mergeLessons(existing, incoming) {
         for (const e of lesson.evidence)
             if (!same.evidence.some(x => x.comment === e.comment && x.kind === e.kind))
                 same.evidence.push(e);
+        refreshText(same, lesson);
         same.updatedAt = lesson.updatedAt;
     }
     let verified = 0;
@@ -174,6 +179,49 @@ export function mergeLessons(existing, incoming) {
     }
     return { lessons, added, verified };
 }
+/** Whether a lesson carries the review point `point` (the same comment on the same pull request). */
+function hasPoint(lesson, point) {
+    return lesson.evidence.some(x => x.kind === 'point' && x.pr === point.pr && x.comment === point.comment);
+}
+/** A person accepted, rejected or dismissed it, or approved or took back a check compiled from it. */
+function decidedByPerson(lesson) {
+    return lesson.evidence.some(e => e.kind === 'accepted' || e.kind === 'rejected' || e.kind === 'dismissed' || e.kind === 'compiled');
+}
+/**
+ * Re-read from the comment it was learned from, an undecided lesson takes the text this version derives; its id
+ * and evidence stay. One a person decided keeps the wording they decided on, and the new one waits as a
+ * suggestion for them. A later comment merged into a lesson never rewrites it.
+ */
+function refreshText(stored, lesson) {
+    const origin = stored.evidence.find(e => e.kind === 'point');
+    if (stored.id === lesson.id || !origin || !hasPoint(lesson, origin))
+        return;
+    if (lesson.text === stored.text) {
+        delete stored.suggestedText;
+        delete stored.suggestedWhy;
+    }
+    else if (decidedByPerson(stored)) {
+        stored.suggestedText = lesson.text;
+        stored.suggestedWhy = 'parser fix';
+    }
+    else
+        stored.text = lesson.text;
+}
+/**
+ * The same lesson: the same id; the same review comment read again, whatever text an earlier version took from it;
+ * shared names on another pull request (two points on one pull request are two points); or a team standard in the
+ * same words.
+ */
+function isSameLesson(stored, lesson) {
+    if (stored.id === lesson.id)
+        return true;
+    if (stored.evidence.some(e => e.kind === 'point' && hasPoint(lesson, e)))
+        return true;
+    const otherPr = !stored.evidence.some(e => lesson.evidence.some(x => x.pr === e.pr));
+    if (stored.file === lesson.file && shared(stored.symbols, lesson.symbols) >= 2 && otherPr)
+        return true;
+    return !stored.file && !lesson.file && sameWords(stored.text, lesson.text);
+}
 /**
  * Lessons that apply to a change, best first. A lesson applies when the change
  * touches its file, or shares at least two specific identifiers with it; a
@@ -278,6 +326,21 @@ export function decideLesson(cwd, id, decision, by, why = '') {
     writeLessons(cwd, lessons);
     return lesson;
 }
+/** A person takes a decided lesson's suggested wording; who and the wording it replaced are kept as evidence. */
+export function acceptSuggestedText(cwd, id, by) {
+    const lessons = readLessons(cwd);
+    const lesson = lessons.find(l => l.id === id);
+    if (!lesson?.suggestedText)
+        return undefined;
+    const at = new Date().toISOString();
+    lesson.evidence.push({ kind: 'reworded', pr: lesson.evidence[0]?.pr ?? 0, comment: `reworded-${at}`, author: by, detail: `${lesson.suggestedWhy ?? 'reworded'}; was: ${lesson.text}`, at });
+    lesson.text = lesson.suggestedText;
+    delete lesson.suggestedText;
+    delete lesson.suggestedWhy;
+    lesson.updatedAt = at;
+    writeLessons(cwd, lessons);
+    return lesson;
+}
 /** An identifier specific enough to link two pieces of code: camelCase, snake_case, or long. */
 export function isSpecific(symbol) {
     return /[a-z][A-Z]|[A-Za-z]_[A-Za-z]/.test(symbol) || symbol.length >= 10;

package/dist/review-learning/review-points.d.ts

@@ -1,4 +1,6 @@
 /** The bullet and numbered lines of a review body: the points a reviewer makes outside any one line. */
 export declare function bodyPoints(body: string): string[];
-/** A comment's first non-empty line, markup removed, at most 140 characters. */
+/** Markdown emphasis off, never the underscores of an identifier (`RESTOCK_CHUNK`) or anything inside a code span. */
+export declare function withoutEmphasis(text: string): string;
+/** A comment's first non-empty line, heading marks and emphasis removed, at most 140 characters. */
 export declare function firstLine(text: string): string;

package/dist/review-learning/review-points.js

@@ -7,8 +7,13 @@ const BULLET = /^\s*(?:[-*]|\d+[.)])\s+(.{8,})$/;
 export function bodyPoints(body) {
     return body.split('\n').map(l => BULLET.exec(l)?.[1]).filter((l) => !!l).map(firstLine);
 }
-/** A comment's first non-empty line, markup removed, at most 140 characters. */
+/** Markdown emphasis off, never the underscores of an identifier (`RESTOCK_CHUNK`) or anything inside a code span. */
+export function withoutEmphasis(text) {
+    return text.split(/(`[^`]*`)/).map(part => part.startsWith('`') ? part
+        : part.replace(/\*+/g, '').replace(/(^|[^\w])__?(?=\S)(.*?\S)__?(?=[^\w]|$)/g, '$1$2')).join('');
+}
+/** A comment's first non-empty line, heading marks and emphasis removed, at most 140 characters. */
 export function firstLine(text) {
-    const line = text.split('\n').find(l => l.trim())?.replace(/[*_`#]/g, '').trim() ?? '';
+    const line = withoutEmphasis(text.split('\n').find(l => l.trim())?.replace(/^\s*#+\s*/, '') ?? '').trim();
     return line.length > 140 ? `${line.slice(0, 137)}...` : line;
 }

package/dist/utils/scanner.d.ts

@@ -8,6 +8,8 @@ export declare class FileScanner {
     private static DEFAULT_PATTERNS;
     private static DEFAULT_IGNORE;
     static findFiles(options: ScannerOptions): Promise<string[]>;
+    /** The selection findFiles makes, over paths listed elsewhere (a commit's files) instead of the disk. */
+    static filterPaths(paths: string[], options: Omit<ScannerOptions, 'cwd'>): string[];
     /**
      * Read file contents. When a FileSystemCache is provided, uses it for
      * shared caching across gates (avoids re-loading per gate).

package/dist/utils/scanner.js

@@ -1,4 +1,5 @@
 import { globby } from 'globby';
+import micromatch from 'micromatch';
 import fs from 'fs-extra';
 import path from 'path';
 import { directoriesAsGlobs, withDirectoryForms } from './glob-paths.js';
@@ -42,6 +43,12 @@ export class FileScanner {
         });
         return files.sort();
     }
+    /** The selection findFiles makes, over paths listed elsewhere (a commit's files) instead of the disk. */
+    static filterPaths(paths, options) {
+        const patterns = (options.patterns || this.DEFAULT_PATTERNS).map(toGlobSeparators);
+        const ignore = withDirectoryForms([...new Set([...this.DEFAULT_IGNORE, ...(options.ignore || [])])].map(toGlobSeparators));
+        return paths.filter(file => micromatch.isMatch(file, patterns, { ignore })).sort();
+    }
     /**
      * Read file contents. When a FileSystemCache is provided, uses it for
      * shared caching across gates (avoids re-loading per gate).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.11.0",
+  "version": "6.11.1-rc.2",
   "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22.13"
@@ -75,11 +75,11 @@
     "@anthropic-ai/sdk": "^0.132.1",
     "pg": "^8.16.3",
     "openai": "^5.23.2",
-    "@rigour-labs/brain-darwin-arm64": "6.11.0",
-    "@rigour-labs/brain-darwin-x64": "6.11.0",
-    "@rigour-labs/brain-linux-arm64": "6.11.0",
-    "@rigour-labs/brain-win-x64": "6.11.0",
-    "@rigour-labs/brain-linux-x64": "6.11.0"
+    "@rigour-labs/brain-linux-arm64": "6.11.1-rc.2",
+    "@rigour-labs/brain-darwin-x64": "6.11.1-rc.2",
+    "@rigour-labs/brain-linux-x64": "6.11.1-rc.2",
+    "@rigour-labs/brain-darwin-arm64": "6.11.1-rc.2",
+    "@rigour-labs/brain-win-x64": "6.11.1-rc.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",