rulereceipt 0.1.58 → 0.1.60

package/dist/parsers/readClaudeMd.js

@@ -36,6 +36,51 @@ function stripFrontmatter(raw) {
     const after = raw.indexOf("\n", end + 1);
     return after === -1 ? "" : raw.slice(after + 1);
 }
+/**
+ * Reads the path scope out of a leading frontmatter block, if it has one.
+ *
+ * Shapes seen in 343 real rule files (2026-09-28): `paths:` as a YAML list
+ * or inline array (Claude Code), `globs:` as inline array, comma list, bare
+ * scalar or YAML list (Cursor, agy). `alwaysApply: true` (Cursor) and
+ * `trigger: always_on` (agy) mean the file is always loaded whatever its
+ * globs say, so they clear the scope. Anything unreadable returns undefined,
+ * which means "always loaded": the pre-existing behaviour.
+ */
+export function readPathScope(raw) {
+    if (!/^---\r?\n/.test(raw))
+        return undefined;
+    const end = raw.indexOf("\n---", 3);
+    if (end === -1)
+        return undefined;
+    const lines = raw.slice(raw.indexOf("\n") + 1, end).split(/\r?\n/);
+    if (lines.some((l) => /^alwaysApply:\s*true\b/i.test(l) || /^trigger:\s*always_on\b/i.test(l)))
+        return undefined;
+    const unquote = (v) => v.trim().replace(/^["']|["']$/g, "").trim();
+    for (let i = 0; i < lines.length; i++) {
+        const m = lines[i].match(/^(paths|globs):\s*(.*)$/);
+        if (!m)
+            continue;
+        const value = m[2].trim();
+        let items = [];
+        if (value.startsWith("[")) {
+            items = value.replace(/^\[|\]$/g, "").split(",").map(unquote);
+        }
+        else if (value.length > 0) {
+            items = value.split(",").map(unquote);
+        }
+        else {
+            for (let j = i + 1; j < lines.length && /^\s*-\s+/.test(lines[j]); j++) {
+                items.push(unquote(lines[j].replace(/^\s*-\s+/, "")));
+            }
+        }
+        items = items.filter((x) => x.length > 0);
+        // `**/*` or `*` scopes to everything: same as no scope.
+        if (items.length === 0 || items.some((x) => x === "**/*" || x === "**" || x === "*"))
+            return undefined;
+        return items;
+    }
+    return undefined;
+}
 export function parseClaudeMd(filePath, source) {
     let raw;
     try {
@@ -44,5 +89,7 @@ export function parseClaudeMd(filePath, source) {
     catch {
         return [];
     }
-    return parseClaudeMdText(stripFrontmatter(raw), source);
+    const rules = parseClaudeMdText(stripFrontmatter(raw), source);
+    const paths = readPathScope(raw);
+    return paths ? rules.map((r) => ({ ...r, paths })) : rules;
 }

package/dist/parsers/transcriptParser.js

@@ -136,6 +136,18 @@ export function parseLine(line) {
                 if (typeof block !== "object" || block === null)
                     continue;
                 const b = block;
+                // User text sent as blocks (VS Code / IDE extension, or any message with
+                // an image) was dropped until 2026-09-28: in real sessions whole
+                // conversations had no user message at all, so every check that reads
+                // what the user said saw nothing. Harness-injected context wrapped in
+                // tags (<ide_opened_file>, <system-reminder>, …) is not the user
+                // speaking and is stripped; what remains is.
+                if (b.type === "text" && typeof b.text === "string") {
+                    const said = b.text.replace(/<([a-z][\w-]*)>[\s\S]*?<\/\1>/gi, "").trim();
+                    if (said.length > 0)
+                        events.push({ role: "user", kind: "text", text: said, timestamp });
+                    continue;
+                }
                 if (b.type === "tool_result") {
                     events.push({
                         role: "user",
@@ -160,11 +172,25 @@ export function parseLine(line) {
 export function readTranscriptFromFile(filePath) {
     const raw = readFileSync(filePath, "utf-8");
     const events = [];
+    // Permission mode is recorded on user turns (and on `permission-mode` entries
+    // in newer versions); it applies to the tool calls that follow. The approval
+    // check needs it to tell "a prompt may have been approved" (default/
+    // acceptEdits/plan) from "no person was asked" (bypassPermissions/dontAsk/auto).
+    let mode;
     for (const line of raw.split("\n")) {
         if (!line.trim())
             continue;
         try {
-            events.push(...parseLine(line));
+            const m = line.match(/"(?:permissionMode|permission_mode)":"([A-Za-z]+)"/) ??
+                (line.includes('"permission-mode"') ? line.match(/"mode":"([A-Za-z]+)"/) : null);
+            if (m)
+                mode = m[1];
+            const parsed = parseLine(line);
+            if (mode)
+                for (const e of parsed)
+                    if (e.kind === "tool_use")
+                        e.permissionMode = mode;
+            events.push(...parsed);
         }
         catch {
             // One malformed/unexpected line must not crash the whole check —

package/dist/report/generateHtmlReport.js

@@ -1,3 +1,4 @@
+import { minimalIssueUrl } from "../wrong.js";
 import { basename } from "node:path";
 import { homedir } from "node:os";
 import { computeTranscriptHash } from "./generateReport.js";
@@ -92,7 +93,7 @@ function ruleLabel(result, all) {
 function countBy(results, status) {
     return results.filter((r) => r.status === status).length;
 }
-function renderResultRow(result, all, hideEvidence) {
+function renderResultRow(result, all, hideEvidence, version = "") {
     const bucket = bucketOf(result);
     const cls = BUCKET_CLASS[bucket];
     const evidence = !hideEvidence && result.evidence
@@ -106,6 +107,9 @@ function renderResultRow(result, all, hideEvidence) {
           </div>
           <h3 class="result__title">${clean(result.ruleTitle)}</h3>
           ${evidence}
+          ${version && (result.status === "FAIL" || result.status === "PASS")
+        ? `<p class="result__wrong"><a href="${clean(minimalIssueUrl(result, version))}" rel="noopener noreferrer">Verdict wrong? Report it</a> (for the full report, run <code>rulereceipt wrong</code> on the machine that ran the check)</p>`
+        : ""}
         </article>`;
 }
 /**
@@ -129,7 +133,7 @@ function sharedEvidence(rs) {
         return null;
     return rs.every((r) => r.evidence === first) ? first : null;
 }
-function renderSection(bucket, results, all) {
+function renderSection(bucket, results, all, version = "") {
     const inSection = results.filter((r) => bucketOf(r) === bucket);
     if (inSection.length === 0)
         return "";
@@ -143,7 +147,7 @@ function renderSection(bucket, results, all) {
         <h2 class="section__title">${clean(BUCKET_LABEL[bucket])} <span class="section__count">${inSection.length}</span></h2>
         ${note}
         ${sharedBlock}
-        ${inSection.map((r) => renderResultRow(r, all, shared !== null)).join("")}
+        ${inSection.map((r) => renderResultRow(r, all, shared !== null, version)).join("")}
       </section>`;
 }
 /**
@@ -232,6 +236,7 @@ export function generateHtmlReport(results, meta) {
   .section__shared { font-size: 13px; color: var(--muted); margin: 0 0 14px; padding: 10px 12px; border-left: 2px solid var(--line); background: var(--panel); border-radius: 0 6px 6px 0; white-space: pre-wrap; }
   .result__id { font-size: 12px; color: var(--muted); }
   .result__title { font-size: 15px; margin: 0 0 6px; font-weight: 600; }
+  .result__wrong { margin: 6px 0 0; font-size: 12px; color: var(--muted); }
   .result__evidence { margin: 0; font-size: 14px; color: var(--muted); white-space: pre-wrap; }
   .note { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; padding: 16px 18px; font-size: 13.5px; color: var(--muted); }
   .note h2 { font-size: 13px; font-weight: 700; letter-spacing: .07em; text-transform: uppercase; color: var(--ink); margin: 0 0 10px; }
@@ -271,7 +276,7 @@ export function generateHtmlReport(results, meta) {
     <tr><th>Tool version</th><td><code>rulereceipt ${clean(meta.toolVersion)}</code></td></tr>
   </table>
 
-${BUCKET_ORDER.map((b) => renderSection(b, results, results)).join("")}
+${BUCKET_ORDER.map((b) => renderSection(b, results, results, meta.toolVersion)).join("")}
 
   <div class="note">
     <h2>How to read this report</h2>

package/dist/rules.d.ts

@@ -1,4 +1,25 @@
 import type { Rule } from "./types.js";
+/**
+ * One candidate rules file, and whether the agent would actually load it.
+ *
+ * `loaded` files are what the tool checks a session against. `shadowed` files
+ * exist on disk but the agent ignores them (a CLAUDE.md at the same level wins
+ * over AGENTS.md; the modern .cursor/rules directory supersedes .cursorrules; a
+ * manual/model_decision .agents/rules file is not auto-loaded). Checking a
+ * session against a shadowed file would be a false accusation, so they are
+ * discovered but never fed to the checker — the load graph reports them so the
+ * "why isn't my rule firing?" question has an honest answer.
+ */
+export type RuleSourceStatus = "loaded" | "shadowed";
+export interface RuleSource {
+    /** Absolute path on disk. */
+    path: string;
+    status: RuleSourceStatus;
+    /** Human label for the format/convention, e.g. "Claude (CLAUDE.md)". */
+    format: string;
+    /** Why a shadowed file is ignored; undefined for loaded files. */
+    note?: string;
+}
 /**
  * Global rules come from every .claude*-prefixed home dir found, not just
  * ~/.claude — a hosted/enterprise Claude Code variant can keep its own
@@ -17,3 +38,31 @@ import type { Rule } from "./types.js";
  * this project has already been bitten by twice.
  */
 export declare function loadRules(cwd: string): Rule[];
+/** One row of the load graph: a rules file and whether the agent loads it. */
+export interface LoadGraphEntry {
+    /** Absolute path on disk. */
+    path: string;
+    scope: "global" | "project";
+    status: RuleSourceStatus;
+    format: string;
+    /** Why a shadowed file is ignored; undefined for loaded files. */
+    note?: string;
+    /**
+     * How many rules the file parses to. For a loaded file this is what the
+     * checker uses; for a shadowed file it is how many rules are being IGNORED,
+     * which is the number worth showing ("AGENTS.md — 5 rules not applied").
+     */
+    ruleCount: number;
+}
+/**
+ * The load graph: every candidate rules file the discovery walk sees, in the
+ * same order and with the same dedup as `loadRules`, tagged loaded or shadowed
+ * and counted. This is what `audit` prints so "why isn't my rule firing?" has
+ * an honest, file-level answer — built on the SAME `ruleSourcesAtLevel` the
+ * checker's own discovery uses, so the graph can never claim a file was loaded
+ * that the checker skipped.
+ *
+ * Memory rules are deliberately NOT listed here: this graph is about files on
+ * disk a user can point at, and memory is summarised separately by the caller.
+ */
+export declare function describeRuleSources(cwd: string): LoadGraphEntry[];

package/dist/rules.js

@@ -1,6 +1,6 @@
 import { homedir } from "node:os";
 import { dirname, join, parse, resolve } from "node:path";
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { parseClaudeMd } from "./parsers/readClaudeMd.js";
 import { findClaudeHomeDirNames } from "./parsers/transcriptParser.js";
 import { loadMemoryRules } from "./parsers/readMemory.js";
@@ -41,65 +41,105 @@ function markdownFilesIn(dir, exts = [".md"]) {
         return [];
     }
 }
-/** Every rules file at one directory level, in documented load order. */
-function ruleFilesAtLevel(dir) {
-    const found = [];
-    const push = (rel) => {
-        const p = join(dir, rel);
-        if (existsSync(p))
-            found.push(p);
-    };
+/**
+ * Every candidate rules file at one directory level, in documented load order,
+ * each tagged loaded or shadowed. This is the single source of truth for both
+ * what gets checked (`ruleFilesAtLevel`, the loaded subset) and the load graph
+ * (`describeRuleSources`) — so the report can never claim a file was loaded
+ * that the checker skipped, or vice versa.
+ */
+function ruleSourcesAtLevel(dir) {
+    const out = [];
     const has = (rel) => existsSync(join(dir, rel));
+    const loaded = (rel, format) => {
+        if (has(rel))
+            out.push({ path: join(dir, rel), status: "loaded", format });
+    };
+    const shadowed = (rel, format, note) => {
+        if (has(rel))
+            out.push({ path: join(dir, rel), status: "shadowed", format, note });
+    };
     // CLAUDE.md shadows AGENTS.md at the same level: as of 2026-09-19 Claude
     // Code loads AGENTS.md ONLY when that level has no CLAUDE.md, and silently
-    // ignores it otherwise. Reading a shadowed AGENTS.md here would check the
-    // session against rules Claude never loaded — a false accusation. `init`
-    // separately WARNS about the shadowed file (see shadowedAgents.ts) so the
-    // rules are not lost silently. Mirrored for the `.claude/` subdir pair.
-    push(join(".claude", "CLAUDE.md"));
-    if (!has(join(".claude", "CLAUDE.md")))
-        push(join(".claude", "AGENTS.md"));
-    for (const rel of RULE_DIRS)
-        found.push(...markdownFilesIn(join(dir, rel)));
-    push("CLAUDE.md");
-    // AGENTS.md (and the singular AGENT.md some tools use) are read only when
-    // there's no CLAUDE.md at this level, mirroring Claude Code's shadow rule.
-    if (!has("CLAUDE.md")) {
-        push("AGENTS.md");
-        push("AGENT.md");
+    // ignores it otherwise. `init` separately WARNS about the shadowed file (see
+    // shadowedAgents.ts). Mirrored for the `.claude/` subdir pair.
+    if (has(join(".claude", "CLAUDE.md"))) {
+        loaded(join(".claude", "CLAUDE.md"), "Claude (.claude/CLAUDE.md)");
+        shadowed(join(".claude", "AGENTS.md"), "AGENTS (.claude/AGENTS.md)", "a CLAUDE.md at the same level wins");
+    }
+    else {
+        loaded(join(".claude", "AGENTS.md"), "AGENTS (.claude/AGENTS.md)");
+    }
+    for (const rel of RULE_DIRS) {
+        for (const f of markdownFilesIn(join(dir, rel)))
+            out.push({ path: f, status: "loaded", format: ".claude/rules" });
     }
-    // .local variants: their precedence relative to the base files is not
-    // documented, so both are kept rather than guessing at a shadow rule.
-    push("CLAUDE.local.md");
-    push("AGENTS.local.md");
+    if (has("CLAUDE.md")) {
+        loaded("CLAUDE.md", "Claude (CLAUDE.md)");
+        // AGENTS.md (and the singular AGENT.md some tools use) are ignored when
+        // there's a CLAUDE.md at this level, mirroring Claude Code's shadow rule.
+        shadowed("AGENTS.md", "AGENTS.md", "a CLAUDE.md at the same level wins");
+        shadowed("AGENT.md", "AGENT.md", "a CLAUDE.md at the same level wins");
+    }
+    else {
+        loaded("AGENTS.md", "AGENTS.md");
+        loaded("AGENT.md", "AGENT.md");
+    }
+    // .local variants: precedence relative to the base files is not documented,
+    // so both are kept rather than guessing at a shadow rule.
+    loaded("CLAUDE.local.md", "Claude (CLAUDE.local.md)");
+    loaded("AGENTS.local.md", "AGENTS (AGENTS.local.md)");
     // Non-Claude rule-file conventions (added 2026-09-26 for multi-tool
-    // support). Each is a plain text/markdown file needing no special access,
-    // read IN ADDITION to Claude's files when present — a rule the project
-    // wrote is a rule to check, and silently ignoring one is the "clean report
-    // on rules never opened" failure this module already guards against. The
-    // engine (classify.ts) is agent-neutral, so it does not matter which tool a
-    // rule was authored for. Precedence is FIXED and documented so rule ids stay
+    // support), read IN ADDITION to Claude's files when present. The engine
+    // (classify.ts) is agent-neutral. Precedence is FIXED so rule ids stay
     // deterministic: Claude family (above), then Cursor, Copilot, Windsurf.
     //
     // Cursor: the modern `.cursor/rules/*.mdc|.md` directory SHADOWS the legacy
-    // single `.cursorrules` file — Cursor itself deprecated `.cursorrules` in
-    // favour of the directory, so reading both would double-count. Same
-    // shadow shape as CLAUDE.md over AGENTS.md above.
+    // single `.cursorrules` file — Cursor deprecated `.cursorrules` in favour of
+    // the directory, so reading both would double-count.
     const cursorRules = markdownFilesIn(join(dir, ".cursor", "rules"), [".mdc", ".md"]);
-    if (cursorRules.length > 0)
-        found.push(...cursorRules);
-    else
-        push(".cursorrules");
+    if (cursorRules.length > 0) {
+        for (const f of cursorRules)
+            out.push({ path: f, status: "loaded", format: "Cursor (.cursor/rules)" });
+        shadowed(".cursorrules", "Cursor (.cursorrules)", "the .cursor/rules/ directory supersedes the legacy file");
+    }
+    else {
+        loaded(".cursorrules", "Cursor (.cursorrules)");
+    }
     // GitHub Copilot: repo-level custom instructions.
-    push(join(".github", "copilot-instructions.md"));
+    loaded(join(".github", "copilot-instructions.md"), "Copilot");
     // Windsurf (Codeium): single rules file.
-    push(".windsurfrules");
-    // Google's newer agent convention (agy) / "agents rules": .agents/rules/*.md,
-    // each with a `trigger:` frontmatter block (stripped by the reader).
-    found.push(...markdownFilesIn(join(dir, ".agents", "rules"), [".md"]));
+    loaded(".windsurfrules", "Windsurf");
+    // Google's newer agent convention / "agents rules": .agents/rules/*.md, each
+    // with a `trigger:` frontmatter block. The trigger decides whether the agent
+    // auto-loads the file, so it decides whether we may check against it:
+    //   - always_on / glob (or no trigger)  → loaded, checked
+    //   - manual / model_decision           → not auto-loaded → shadowed
+    // README fragments in the directory are notes, not rules, so they are skipped
+    // entirely (not even reported — they were never a candidate rule).
+    for (const file of markdownFilesIn(join(dir, ".agents", "rules"), [".md"])) {
+        if (/(^|[/\\])readme\.md$/i.test(file))
+            continue;
+        let head = "";
+        try {
+            head = readFileSync(file, "utf-8").slice(0, 600);
+        }
+        catch {
+            continue;
+        }
+        if (/^---[\s\S]*?^\s*trigger:\s*(?:manual|model_decision)\b/m.test(head)) {
+            out.push({ path: file, status: "shadowed", format: ".agents/rules", note: "trigger is manual/model_decision — the agent does not auto-load it" });
+            continue;
+        }
+        out.push({ path: file, status: "loaded", format: ".agents/rules" });
+    }
     // Gemini CLI: single rules file (its AGENTS.md equivalent).
-    push("GEMINI.md");
-    return found;
+    loaded("GEMINI.md", "Gemini");
+    return out;
+}
+/** Every rules file at one directory level that the agent actually loads. */
+function ruleFilesAtLevel(dir) {
+    return ruleSourcesAtLevel(dir).filter((s) => s.status === "loaded").map((s) => s.path);
 }
 /**
  * Walks from the working directory up toward the repository root,
@@ -116,8 +156,8 @@ function ruleFilesAtLevel(dir) {
  * or the home directory — is never pulled into an unrelated project.
  * Global rules are handled separately, deliberately, below.
  */
-function findProjectRuleFiles(cwd) {
-    const found = [];
+function projectLevels(cwd) {
+    const levels = [];
     const { root } = parse(cwd);
     const home = homedir();
     let dir = cwd;
@@ -131,7 +171,7 @@ function findProjectRuleFiles(cwd) {
         // it; loadRules dedupes that against the global pass.
         if (dir === home && dir !== cwd)
             break;
-        found.push(...ruleFilesAtLevel(dir));
+        levels.push(dir);
         // stop AT the repo root (inclusive) — its rules do apply
         if (existsSync(join(dir, ".git")))
             break;
@@ -142,7 +182,10 @@ function findProjectRuleFiles(cwd) {
             break;
         dir = parent;
     }
-    return found;
+    return levels;
+}
+function findProjectRuleFiles(cwd) {
+    return projectLevels(cwd).flatMap((dir) => ruleFilesAtLevel(dir));
 }
 /**
  * Global rules come from every .claude*-prefixed home dir found, not just
@@ -189,3 +232,46 @@ export function loadRules(cwd) {
     rules.push(...loadMemoryRules(cwd));
     return rules;
 }
+/**
+ * The load graph: every candidate rules file the discovery walk sees, in the
+ * same order and with the same dedup as `loadRules`, tagged loaded or shadowed
+ * and counted. This is what `audit` prints so "why isn't my rule firing?" has
+ * an honest, file-level answer — built on the SAME `ruleSourcesAtLevel` the
+ * checker's own discovery uses, so the graph can never claim a file was loaded
+ * that the checker skipped.
+ *
+ * Memory rules are deliberately NOT listed here: this graph is about files on
+ * disk a user can point at, and memory is summarised separately by the caller.
+ */
+export function describeRuleSources(cwd) {
+    const entries = [];
+    const seen = new Set();
+    const add = (src, scope) => {
+        const key = resolve(src.path);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        let ruleCount = 0;
+        try {
+            ruleCount = parseClaudeMd(src.path, scope).length;
+        }
+        catch {
+            /* unreadable: reported with count 0 rather than dropped */
+        }
+        entries.push({ path: src.path, scope, status: src.status, format: src.format, note: src.note, ruleCount });
+    };
+    // Globals first, so a file reachable both ways keeps its "global" label —
+    // mirrors loadRules' dedup order exactly.
+    for (const dirName of findClaudeHomeDirNames()) {
+        const base = join(homedir(), dirName);
+        if (existsSync(join(base, "CLAUDE.md")))
+            add({ path: join(base, "CLAUDE.md"), status: "loaded", format: "Claude (global CLAUDE.md)" }, "global");
+        for (const file of markdownFilesIn(join(base, "rules")))
+            add({ path: file, status: "loaded", format: "Claude (global rules)" }, "global");
+    }
+    for (const dir of projectLevels(cwd)) {
+        for (const src of ruleSourcesAtLevel(dir))
+            add(src, "project");
+    }
+    return entries;
+}

package/dist/types.d.ts

@@ -3,6 +3,14 @@ export interface Rule {
     title: string;
     text: string;
     source: "global" | "project";
+    /**
+     * Path scope from the rules file's frontmatter (`paths:` in Claude Code
+     * `.claude/rules/*.md`, `globs:` in Cursor `.mdc` / agy `.agents/rules`).
+     * Claude Code only loads a path-scoped rule once the session touches a
+     * matching file, so judging it in a session that never did checks Claude
+     * against a rule it was never shown. Absent = always loaded.
+     */
+    paths?: string[];
 }
 export interface TranscriptTextEvent {
     role: "user" | "assistant";
@@ -27,6 +35,14 @@ export interface TranscriptToolUseEvent {
      * the test run that a completion claim depended on.
      */
     toolUseId?: string;
+    /**
+     * The Claude Code permission mode in force when this call was made, when the
+     * transcript records one (`permissionMode` on user turns). Added 2026-09-28
+     * for the approval check: in `default`/`acceptEdits`/`plan` a shell command
+     * may have been approved in the permission prompt, which leaves no trace in
+     * the transcript; in `bypassPermissions`/`dontAsk`/`auto` no person was asked.
+     */
+    permissionMode?: string;
 }
 export interface TranscriptToolResultEvent {
     role: "user";

package/dist/wrong.d.ts

@@ -0,0 +1,57 @@
+import type { CheckResult, Rule, TranscriptEvent } from "./types.js";
+/**
+ * `rulereceipt wrong <rule>` — turn "this verdict is wrong" into a report
+ * someone can actually file, without sending anything anywhere.
+ *
+ * Added 2026-09-28. The "A result looks wrong" issue template already asked the
+ * right questions, but nothing in the tool pointed to it, and filling it meant
+ * copying the rule, the verdict and the evidence by hand. A user who sees a
+ * wrong verdict and has to do that mostly uninstalls instead, and the project
+ * loses the one kind of report every accuracy fix has come from.
+ *
+ * Privacy: nothing is sent. The report is written to a local file and shown
+ * first; the issue link is printed for the user to open themselves. Obvious
+ * secrets, the home directory and email addresses are masked before either is
+ * produced, and the user is told to read it before sharing.
+ */
+export declare const ISSUE_BASE = "https://github.com/rulereceipt/rulereceipt/issues/new";
+/** The dropdown options of .github/ISSUE_TEMPLATE/wrong-result.yml, verbatim. */
+export declare function reportedLabel(r: CheckResult): string;
+/** Masks the things most likely to be private. Not a guarantee — the user is told to read it. */
+export declare function redact(text: string, home?: string): string;
+/**
+ * A few events around the one the evidence quotes, so the reader can see what
+ * happened just before and after. Found by the longest quoted fragment of the
+ * evidence; if nothing matches, no excerpt (never a guessed one).
+ */
+export declare function excerptAround(events: TranscriptEvent[], evidence: string, radius?: number): string[];
+export interface WrongReportInput {
+    version: string;
+    rule: Rule;
+    result: CheckResult;
+    events: TranscriptEvent[];
+    withContext?: boolean;
+    home?: string;
+}
+export interface WrongReport {
+    handle: string;
+    markdown: string;
+    issueUrl: string;
+}
+export declare function buildWrongReport(input: WrongReportInput): WrongReport;
+/**
+ * The link for a shared report (HTML). No rule text and no evidence in it: that
+ * report is often sent to someone else, and a link should not leak what the
+ * page deliberately shows only to its reader.
+ */
+export declare function minimalIssueUrl(result: CheckResult, version: string): string;
+/** Finds the result a user means: by 12-char handle, or by id when that id is unique. */
+export declare function findTarget(query: string, rules: Rule[], results: CheckResult[]): {
+    rule: Rule;
+    result: CheckResult;
+} | {
+    ambiguous: Array<{
+        handle: string;
+        title: string;
+    }>;
+} | null;