@verevoir/review 0.3.0 → 0.3.1

package/dist/cli/footer.d.ts

@@ -4,6 +4,8 @@ export type RouteName = 'env' | 'key-file' | 'claude-cli';
 export declare function modelText(requested: string, calls: readonly RawCall[]): string;
 /** The one line saying how many [blocking] findings tier enforcement downgraded; none for 0. */
 export declare function tierLine(downgraded: number): string | undefined;
-export declare function renderFooter(requested: string, route: RouteName, calls: readonly RawCall[], downgraded?: number): string;
+/** The one line saying how many smells tier enforcement promoted to [blocking]; none for 0. */
+export declare function promotedLine(promoted: number): string | undefined;
+export declare function renderFooter(requested: string, route: RouteName, calls: readonly RawCall[], downgraded?: number, promoted?: number): string;
 /** One stderr line per lens. */
 export declare function usageLines(calls: readonly RawCall[]): string[];

package/dist/cli/footer.js

@@ -36,11 +36,20 @@ export function tierLine(downgraded) {
         ? `Tier: ${String(downgraded)} blocking finding(s) downgraded: no Reject/Expect signal quoted`
         : undefined;
 }
-export function renderFooter(requested, route, calls, downgraded = 0) {
+/** The one line saying how many smells tier enforcement promoted to [blocking]; none for 0. */
+export function promotedLine(promoted) {
+    return promoted > 0
+        ? `Tier: ${String(promoted)} finding(s) promoted: quotes a Reject signal`
+        : undefined;
+}
+export function renderFooter(requested, route, calls, downgraded = 0, promoted = 0) {
     const lines = ['---', '', `Judged with ${modelText(requested, calls)}, route: ${route}.`];
     const tier = tierLine(downgraded);
     if (tier !== undefined)
         lines.push('', tier);
+    const promotion = promotedLine(promoted);
+    if (promotion !== undefined)
+        lines.push('', promotion);
     if (calls.length > 0) {
         lines.push('', 'Per-lens usage and wall time:', '');
         for (const call of byLens(calls)) {

package/dist/cli/review.js

@@ -24,7 +24,7 @@ import { buildPrompt, renderPrompt } from '../prompt.js';
 import { deriveLensSet, extractBar } from '../practice-lenses.js';
 import { buildFileContext, NO_FILE_CONTEXT_NOTE } from '../context-files.js';
 import { buildReferences } from '../references.js';
-import { renderFooter, tierLine, usageLines } from './footer.js';
+import { promotedLine, renderFooter, tierLine, usageLines } from './footer.js';
 /** Governance's pinned default, sent to both routes. */
 export const DEFAULT_MODEL = 'claude-opus-5-5';
 /** Governance's default output-token budget (billed route only). */
@@ -470,14 +470,25 @@ export async function main(argv, env, io, deps) {
             dedup: parsed.dedup,
             ...(derived === undefined
                 ? {}
-                : { tierSignals: derived.signals, practiceNames: derived.practiceNames }),
+                : {
+                    tierSignals: derived.signals,
+                    tierRejects: derived.rejects,
+                    practiceIds: derived.practiceIds,
+                    practiceNames: derived.practiceNames,
+                }),
         }, (call) => void calls.push(call));
         for (const line of usageLines(calls))
             io.stderr(line);
         const tier = tierLine(result.downgraded);
         if (tier !== undefined)
             io.stderr(`${tier}\n`);
-        const footer = `\n\n${renderFooter(model, route, calls, result.downgraded)}`;
+        const promotion = promotedLine(result.promoted);
+        if (promotion !== undefined)
+            io.stderr(`${promotion}\n`);
+        // Audit trail for tier decisions behind merged groups: stderr, not the report (see dedup.ts).
+        for (const line of result.dedupAudit)
+            io.stderr(line);
+        const footer = `\n\n${renderFooter(model, route, calls, result.downgraded, result.promoted)}`;
         const note = derived !== undefined && derived.untagged.length > 0
             ? `\n\n> ${String(derived.untagged.length)} practice(s) had no "lens:" tag and were ` +
                 `not reviewed: ${derived.untagged.join(', ')}`

package/dist/dedup.d.ts

@@ -29,6 +29,12 @@ export type DedupResult = {
 };
 /** Ask the model to group `items`; members come back in their input order. */
 export declare function dedupFindings(items: readonly NumberedFinding[], review: Reviewer): Promise<DedupResult>;
+/**
+ * The audit trail of every MERGED group (two or more members): one stderr line per member, with
+ * its own lens id, tier and text, because the report shows only the highest-tier member's text.
+ * Singletons are not listed: the report already shows them as they are.
+ */
+export declare function dedupAuditLines(groups: readonly (readonly NumberedFinding[])[]): string[];
 /**
  * The report view of each group: the highest tier among its members, the text of its highest-tier member (the first blocking one, else the first),
  * and who raised it, naming the practices of each lens that the members' text mentions (by id

package/dist/dedup.js

@@ -51,7 +51,8 @@ export function buildDedupPrompt(items) {
         'Reply with ONLY a JSON array of arrays of ids, for example ' +
             '[["a:0","b:1"],["a:1"],["b:0"]]. No prose, no markdown fence, no verdict line.',
     ].join('\n');
-    return { shared, perLens };
+    // `cache: false`: no other call reads this `shared`, so a cache write is pure cost.
+    return { shared, perLens, cache: false };
 }
 /** Parse and validate a reply: every one of `ids` in exactly one group. */
 export function parseGroups(reply, ids) {
@@ -119,6 +120,23 @@ export async function dedupFindings(items, review) {
         .sort((a, b) => (position.get(a[0]?.id ?? '') ?? 0) - (position.get(b[0]?.id ?? '') ?? 0));
     return { ok: true, groups };
 }
+/**
+ * The audit trail of every MERGED group (two or more members): one stderr line per member, with
+ * its own lens id, tier and text, because the report shows only the highest-tier member's text.
+ * Singletons are not listed: the report already shows them as they are.
+ */
+export function dedupAuditLines(groups) {
+    const lines = [];
+    groups.forEach((members, index) => {
+        if (members.length < 2)
+            return;
+        for (const { id, finding } of members) {
+            const text = `${finding.summary} ${finding.detail ?? ''}`.replace(/\s+/g, ' ').trim();
+            lines.push(`dedup group ${String(index + 1)}: ${id} [${finding.blocking ? 'blocking' : 'smell'}] ${text}\n`);
+        }
+    });
+    return lines;
+}
 /**
  * The report view of each group: the highest tier among its members, the text of its highest-tier member (the first blocking one, else the first),
  * and who raised it, naming the practices of each lens that the members' text mentions (by id

package/dist/practice-lenses.d.ts

@@ -20,6 +20,10 @@ export interface DerivedLenses {
      * practices' sensors (label stripped). A [blocking] finding must quote one of these.
      */
     readonly signals: Readonly<Record<string, readonly string[]>>;
+    /** Per lens id: only the `_Reject:_` lines of `signals`. A smell quoting one is promoted. */
+    readonly rejects: Readonly<Record<string, readonly string[]>>;
+    /** Every practice id in the corpus (tagged or not): ignored when matching a quote. */
+    readonly practiceIds: readonly string[];
     /** Per lens id: its practices' ids and H1 titles ('' when none), to name them in a report. */
     readonly practiceNames: Readonly<Record<string, readonly {
         readonly id: string;
@@ -60,6 +64,11 @@ export declare function extractSensorHalf(markdown: string): string | undefined;
  * continuation lines (not a new bullet, heading or bold label) are joined onto their line.
  */
 export declare function extractSignalLines(sensor: string): string[];
+/** As `extractSignalLines`, keeping which label each line carried. */
+export declare function extractLabelledSignals(sensor: string): {
+    readonly kind: 'reject' | 'expect';
+    readonly text: string;
+}[];
 /**
  * Group practice files by their `lens:` value and build one lens per group.
  * Files are taken in name order, a top-level README.md and non-.md files are

package/dist/practice-lenses.js

@@ -130,20 +130,25 @@ export function extractSensorHalf(markdown) {
         return undefined;
     return slice.trim();
 }
-const SIGNAL_LINE_RE = /^\s*(?:[-*+]\s+)?[_*]{1,2}(?:Reject|Expect):[_*]{1,2}\s*(.*)$/i;
+const SIGNAL_LINE_RE = /^\s*(?:[-*+]\s+)?[_*]{1,2}(Reject|Expect):[_*]{1,2}\s*(.*)$/i;
 const BLOCK_START_RE = /^\s*(?:[-*+]\s|\d+\.\s|#|\*\*)/;
 /**
  * The text of each `_Reject:_` / `_Expect:_` line in a sensor half, label stripped. Indented
  * continuation lines (not a new bullet, heading or bold label) are joined onto their line.
  */
 export function extractSignalLines(sensor) {
+    return extractLabelledSignals(sensor).map((s) => s.text);
+}
+/** As `extractSignalLines`, keeping which label each line carried. */
+export function extractLabelledSignals(sensor) {
     const out = [];
     const lines = sensor.split(/\r?\n/);
     for (let i = 0; i < lines.length; i++) {
         const match = SIGNAL_LINE_RE.exec(lines[i] ?? '');
         if (match === null)
             continue;
-        let text = (match[1] ?? '').trim();
+        const kind = (match[1] ?? '').toLowerCase() === 'reject' ? 'reject' : 'expect';
+        let text = (match[2] ?? '').trim();
         while (i + 1 < lines.length) {
             const next = lines[i + 1] ?? '';
             if (next.trim() === '' || !/^\s+\S/.test(next) || BLOCK_START_RE.test(next))
@@ -152,7 +157,7 @@ export function extractSignalLines(sensor) {
             i++;
         }
         if (text !== '')
-            out.push(text);
+            out.push({ kind, text });
     }
     return out;
 }
@@ -169,11 +174,14 @@ export function deriveLensSet(files) {
         .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
     const byLens = new Map();
     const signals = {};
+    const rejects = {};
+    const practiceIds = [];
     const practiceNames = {};
     const untagged = [];
     const missingSensor = [];
     for (const file of eligible) {
         const id = file.name.slice(0, -'.md'.length);
+        practiceIds.push(id);
         const lensId = parseLensFrontmatter(file.text);
         if (lensId === undefined) {
             untagged.push(id);
@@ -186,7 +194,9 @@ export function deriveLensSet(files) {
         const title = parseTitle(file.text);
         group.push({ id, title, sensor });
         byLens.set(lensId, group);
-        (signals[lensId] ??= []).push(...(sensor === undefined ? [] : extractSignalLines(sensor)));
+        const labelled = sensor === undefined ? [] : extractLabelledSignals(sensor);
+        (signals[lensId] ??= []).push(...labelled.map((s) => s.text));
+        (rejects[lensId] ??= []).push(...labelled.filter((s) => s.kind === 'reject').map((s) => s.text));
         (practiceNames[lensId] ??= []).push({ id, title: title ?? '' });
     }
     const lensIds = [...byLens.keys()].sort();
@@ -213,6 +223,8 @@ export function deriveLensSet(files) {
         untagged,
         missingSensor,
         signals,
+        rejects,
+        practiceIds,
         practiceNames,
     };
 }

package/dist/prompt.d.ts

@@ -94,6 +94,9 @@ export interface Prompt {
     readonly shared: string;
     /** The only part that varies by lens. Goes last. */
     readonly perLens: string;
+    /** `false` for a call whose `shared` no other call reads (the dedup call): a transport that
+     * marks `shared` cacheable must not, as the cache write would never be read. */
+    readonly cache?: false;
 }
 /** The two halves in the one order that preserves the shared prefix. */
 export declare function renderPrompt(prompt: Prompt): string;

package/dist/report.js

@@ -49,7 +49,9 @@ function verdictHeading(lens, verdict) {
     if (result === undefined)
         return lens;
     const reason = result.reason === undefined ? '' : result.reason.trim();
-    return reason === '' ? `${lens}: ${result.outcome}` : `${lens}: ${result.outcome}: ${reason}`;
+    // The model's reason was written for the outcome it gave, not the one tier enforcement left.
+    const word = result.tierAdjusted === true ? `${result.outcome} (after tier enforcement)` : result.outcome;
+    return reason === '' ? `${lens}: ${word}` : `${lens}: ${word}: ${reason}`;
 }
 export function renderReport(verdict, context) {
     const lines = [
@@ -150,17 +152,19 @@ export function renderReport(verdict, context) {
             'the reason each lens gave.', '');
     }
     if (verdict.outcome === 'approved') {
+        // What the reader was shown: de-duplicated groups when the findings were merged.
+        const shownSmells = dedup === undefined ? smellCount : dedup.groups.filter((g) => !g.blocking).length;
         const base = verdict.outOfScope.length > 0
-            ? smellCount > 0
+            ? shownSmells > 0
                 ? 'Every lens with something in scope reviewed it. Nothing it found held this up. See ' +
                     'above for the lens(es) that had nothing in scope for this change.'
                 : 'Every lens with something in scope reviewed it and found nothing. See above for the ' +
                     'lens(es) that had nothing in scope for this change.'
-            : smellCount > 0
+            : shownSmells > 0
                 ? 'Every lens reviewed. Nothing it found held this up.'
                 : 'Every lens reviewed and none had a finding.';
-        const suffix = smellCount > 0
-            ? ` ${smellCount} non-blocking finding(s) are listed above; none of them held this up. ` +
+        const suffix = shownSmells > 0
+            ? ` ${shownSmells} non-blocking finding(s) are listed above; none of them held this up. ` +
                 'If this merges as-is, file each as a follow-up issue before merging, referenced ' +
                 'as `owner/repo#123`.'
             : '';

package/dist/reviewer-anthropic.js

@@ -100,7 +100,13 @@ export function anthropicReviewer(config, post, onResolvedModel) {
             // The shared half, marked cacheable — `Prompt`'s ordering contract made
             // real: identical bytes for every lens, sent first, so a five-lens
             // panel pays for the diff once.
-            system: [{ type: 'text', text: prompt.shared, cache_control: { type: 'ephemeral' } }],
+            // Unless the prompt says nothing else reads it (`cache: false`): a write nobody reads
+            // is pure cost.
+            system: [
+                prompt.cache === false
+                    ? { type: 'text', text: prompt.shared }
+                    : { type: 'text', text: prompt.shared, cache_control: { type: 'ephemeral' } },
+            ],
             messages: [{ role: 'user', content: prompt.perLens }],
         });
         let response;

package/dist/run-review.d.ts

@@ -41,6 +41,10 @@ export interface ReviewNodeInput {
     /** Per lens id: the signal lines its [blocking] findings must quote (see tier.ts). A lens
      * with no entry is left as it was. Absent: no tier enforcement. */
     readonly tierSignals?: Readonly<Record<string, readonly string[]>>;
+    /** Per lens id: just the `_Reject:_` lines of `tierSignals`; a smell quoting one is promoted. */
+    readonly tierRejects?: Readonly<Record<string, readonly string[]>>;
+    /** Every practice id in the corpus; ignored when matching a quote (see tier.ts). */
+    readonly practiceIds?: readonly string[];
     /** After the panel (and tier enforcement), make ONE extra call through the same reviewer to
      * group findings that describe the same defect (see dedup.ts). Off when absent. */
     readonly dedup?: boolean;
@@ -60,5 +64,9 @@ export interface ReviewNodeResult {
     readonly prompts: ReadonlyMap<string, Prompt>;
     /** How many [blocking] findings tier enforcement downgraded to smells (0 when none). */
     readonly downgraded: number;
+    /** How many smells tier enforcement promoted to [blocking] (0 when none). */
+    readonly promoted: number;
+    /** Stderr lines, one per member of every merged dedup group (empty when none merged). */
+    readonly dedupAudit: readonly string[];
 }
 export declare function runReviewNode(input: ReviewNodeInput, onCall?: (call: RawCall) => void): Promise<ReviewNodeResult>;

package/dist/run-review.js

@@ -36,7 +36,7 @@ import { describeThrown } from './raw-call.js';
 import { normaliseReviewerReply } from './panel.js';
 import { warmFirst } from './warm-first.js';
 import { enforceTier } from './tier.js';
-import { dedupFindings, numberFindings, toGroupViews } from './dedup.js';
+import { dedupAuditLines, dedupFindings, numberFindings, toGroupViews } from './dedup.js';
 // RECORD-NEVER-PREDICT discipline: `onCall` is OPTIONAL so every existing
 // call site, and every test that builds a ReviewNodeInput by hand, is
 // unaffected by this addition.
@@ -116,17 +116,22 @@ export async function runReviewNode(input, onCall) {
     const prompts = panel.prompts;
     // C1 runs before C2: de-duplication sees the tiers as enforced.
     const tiered = input.tierSignals === undefined
-        ? { verdict: panel.verdict, downgraded: 0 }
-        : enforceTier(panel.verdict, input.tierSignals);
+        ? { verdict: panel.verdict, downgraded: 0, promoted: 0 }
+        : enforceTier(panel.verdict, input.tierSignals, {
+            ...(input.tierRejects === undefined ? {} : { rejects: input.tierRejects }),
+            ...(input.practiceIds === undefined ? {} : { practiceIds: input.practiceIds }),
+        });
     const verdict = tiered.verdict;
     let dedup;
     let dedupSkipped;
+    let dedupAudit = [];
     if (input.dedup === true && verdict.findings.length >= 2) {
         const numbered = numberFindings(verdict.findings);
         // The observed reviewer, outside warm-first: the extra call is recorded like a lens call.
         const outcome = await dedupFindings(numbered, observedReviewer);
         if (outcome.ok) {
             dedup = { groups: toGroupViews(outcome.groups, input.practiceNames), total: numbered.length };
+            dedupAudit = dedupAuditLines(outcome.groups);
         }
         else {
             dedupSkipped = outcome.reason;
@@ -144,5 +149,7 @@ export async function runReviewNode(input, onCall) {
         exitCode: exitCodeFor(verdict.outcome),
         prompts,
         downgraded: tiered.downgraded,
+        promoted: tiered.promoted,
+        dedupAudit,
     };
 }

package/dist/tier.d.ts

@@ -3,18 +3,33 @@ import type { Verdict } from './verdict.js';
 export declare const MIN_QUOTE = 24;
 /** Appended to the summary of a finding that was downgraded. */
 export declare const DOWNGRADE_NOTE = " (downgraded: no signal quoted)";
+/** Appended to the summary of a smell that was promoted. */
+export declare const PROMOTE_NOTE = " (promoted: quotes a Reject signal)";
 export declare function normaliseForQuote(text: string): string;
-/** Whether `text` contains a verbatim quote (per the rule above) of any of `signals`. */
-export declare function quotesSignal(text: string, signals: readonly string[]): boolean;
+/**
+ * Whether `text` contains a verbatim quote (per the rule above) of any of `signals`.
+ * `practiceIds` are the corpus's practice ids, which are ignored on both sides.
+ */
+export declare function quotesSignal(text: string, signals: readonly string[], practiceIds?: readonly string[]): boolean;
+export interface TierContext {
+    /** Per lens id: just the `_Reject:_` lines. A lens with an entry can have smells promoted. */
+    readonly rejects?: Readonly<Record<string, readonly string[]>>;
+    /** Every practice id in the corpus, ignored when matching. */
+    readonly practiceIds?: readonly string[];
+}
 export interface TierResult {
     readonly verdict: Verdict;
     /** How many findings were downgraded. */
     readonly downgraded: number;
+    /** How many smells were promoted to [blocking]. */
+    readonly promoted: number;
 }
 /**
- * Downgrade unquoted [blocking] findings of every lens that has an entry in `signals`, then
- * re-aggregate. A lens that was `rejected` and is left with no [blocking] finding counts as
- * `approved`. Lenses without an entry (bundled lenses) are untouched. With nothing to
- * downgrade the verdict is returned as it was.
+ * Downgrade unquoted [blocking] findings of every lens that has an entry in `signals`, promote
+ * smells that quote one of the lens's own Reject lines (`context.rejects`), then re-aggregate.
+ * A lens that was `rejected` and is left with no [blocking] finding counts as `approved`; one
+ * that was `approved` and gained a promoted finding counts as `rejected`; either is marked
+ * `tierAdjusted`. Lenses without an entry (bundled lenses) are untouched. With nothing changed
+ * the verdict is returned as it was.
  */
-export declare function enforceTier(verdict: Verdict, signals: Readonly<Record<string, readonly string[]>>): TierResult;
+export declare function enforceTier(verdict: Verdict, signals: Readonly<Record<string, readonly string[]>>, context?: TierContext): TierResult;

package/dist/tier.js

@@ -1,7 +1,9 @@
 // Enforces the tier in code. A derived lens is told to tag a finding [blocking] only when it
 // quotes the signal it fails, but a model honours that loosely. After parsing, every [blocking]
 // finding of a derived lens is checked against THAT lens's own practices' `_Reject:_` /
-// `_Expect:_` lines; one that quotes none is downgraded to [smell] and the lens's outcome is
+// `_Expect:_` lines; one that quotes none is downgraded to [smell]. The mirror: a [smell]
+// finding that quotes one of the lens's own `_Reject:_` lines (not `_Expect:_`) is promoted to
+// [blocking], because the bar says a Reject blocks anywhere. The lens's outcome is then
 // recomputed. Deterministic: no model call.
 //
 // MATCHING RULE. Both sides are normalised (lower-cased; markdown emphasis `*` `_` and
@@ -9,11 +11,28 @@
 // finding (summary + detail) quotes a signal line when it contains a contiguous
 // MIN_QUOTE-character (24) run of the signal's normalised text, or the whole normalised line
 // when the line is shorter than that.
+//
+// PRACTICE IDS DO NOT COUNT AS QUOTING. Lens signal lines cross-reference other practices by id
+// (a Reject line may say "see complexity-matches-the-problem"), so a finding that merely NAMES
+// that id would otherwise match 24+ characters without quoting anything. Before matching, every
+// practice id of the corpus (and any backticked kebab-case token) is replaced, in BOTH the
+// signal line and the finding, by a break mark. A run of 24 characters can then never span or
+// consist of an id, and a signal line that is only ids has nothing left to quote. Chosen over
+// "the run must contain a non-id word": stripping is one rule applied to both sides, and it
+// cannot be satisfied by an id plus one filler word.
+//
+// WORD BOUNDARIES. After normalising, every run of characters that are not letters or digits
+// becomes one space, and both sides are padded with a space at each end. So the start or end of
+// a text, and punctuation beside a word, all read as the same single space: a phrase at the
+// start of a finding, after "(", or before ":" matches as it would after a space. The
+// 24-character bar is unchanged; "unpinned/unremarked" is still not "unpinned and unremarked".
 import { aggregate } from './verdict.js';
 /** The shortest verbatim run of a signal line that counts as quoting it. */
 export const MIN_QUOTE = 24;
 /** Appended to the summary of a finding that was downgraded. */
 export const DOWNGRADE_NOTE = ' (downgraded: no signal quoted)';
+/** Appended to the summary of a smell that was promoted. */
+export const PROMOTE_NOTE = ' (promoted: quotes a Reject signal)';
 export function normaliseForQuote(text) {
     return text
         .replace(/[*_`]/g, '')
@@ -22,21 +41,59 @@ export function normaliseForQuote(text) {
         .trim()
         .toLowerCase();
 }
-/** Whether `text` contains a verbatim quote (per the rule above) of any of `signals`. */
-export function quotesSignal(text, signals) {
-    const haystack = normaliseForQuote(text);
+/** Stands where an id was; survives normalisation and cannot occur in prose. */
+const ID_MARK = '\u0001';
+const BACKTICKED_ID = /`[a-z0-9]+(?:-[a-z0-9]+)+`/g;
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function idPattern(ids) {
+    const sorted = [...new Set(ids.map((id) => id.toLowerCase()).filter((id) => id !== ''))].sort((a, b) => b.length - a.length);
+    if (sorted.length === 0)
+        return undefined;
+    return new RegExp(`(?<![a-z0-9-])(?:${sorted.map(escapeRegExp).join('|')})(?![a-z0-9-])`, 'g');
+}
+function markIds(text, pattern) {
+    const marked = text.toLowerCase().replace(BACKTICKED_ID, ID_MARK);
+    return pattern === undefined ? marked : marked.replace(pattern, ID_MARK);
+}
+/** Normalised, punctuation read as a space, padded with a space each end; '' when nothing is left. */
+function boundaryForm(text) {
+    const spaced = normaliseForQuote(text)
+        .replace(/[^\p{L}\p{N}\u0001]+/gu, ' ')
+        .trim();
+    return spaced === '' ? '' : ` ${spaced} `;
+}
+/** A 24-character run of `needle` in `haystack`; a needle of 24 or fewer only whole, if allowed. */
+function quotesRun(haystack, needle, wholeIfShort) {
+    if (needle === '')
+        return false;
+    if (needle.length <= MIN_QUOTE)
+        return wholeIfShort && haystack.includes(needle);
+    for (let i = 0; i + MIN_QUOTE <= needle.length; i++) {
+        if (haystack.includes(needle.slice(i, i + MIN_QUOTE)))
+            return true;
+    }
+    return false;
+}
+/**
+ * Whether `text` contains a verbatim quote (per the rule above) of any of `signals`.
+ * `practiceIds` are the corpus's practice ids, which are ignored on both sides.
+ */
+export function quotesSignal(text, signals, practiceIds = []) {
+    const pattern = idPattern(practiceIds);
+    const haystack = boundaryForm(markIds(text, pattern));
     for (const signal of signals) {
-        const needle = normaliseForQuote(signal);
-        if (needle === '')
-            continue;
-        if (needle.length <= MIN_QUOTE) {
-            if (haystack.includes(needle))
-                return true;
-            continue;
+        const marked = markIds(signal, pattern);
+        if (marked.includes(ID_MARK)) {
+            // Each stretch between ids is quoted (or not) on its own; a short one never counts.
+            for (const stretch of marked.split(ID_MARK)) {
+                if (quotesRun(haystack, boundaryForm(stretch), false))
+                    return true;
+            }
         }
-        for (let i = 0; i + MIN_QUOTE <= needle.length; i++) {
-            if (haystack.includes(needle.slice(i, i + MIN_QUOTE)))
-                return true;
+        else if (quotesRun(haystack, boundaryForm(marked), true)) {
+            return true;
         }
     }
     return false;
@@ -50,39 +107,66 @@ function hasBlocking(findings) {
     return findings.some((f) => f.blocking && !isNone(f));
 }
 /**
- * Downgrade unquoted [blocking] findings of every lens that has an entry in `signals`, then
- * re-aggregate. A lens that was `rejected` and is left with no [blocking] finding counts as
- * `approved`. Lenses without an entry (bundled lenses) are untouched. With nothing to
- * downgrade the verdict is returned as it was.
+ * Downgrade unquoted [blocking] findings of every lens that has an entry in `signals`, promote
+ * smells that quote one of the lens's own Reject lines (`context.rejects`), then re-aggregate.
+ * A lens that was `rejected` and is left with no [blocking] finding counts as `approved`; one
+ * that was `approved` and gained a promoted finding counts as `rejected`; either is marked
+ * `tierAdjusted`. Lenses without an entry (bundled lenses) are untouched. With nothing changed
+ * the verdict is returned as it was.
  */
-export function enforceTier(verdict, signals) {
+export function enforceTier(verdict, signals, context = {}) {
+    const ids = context.practiceIds ?? [];
     let downgraded = 0;
+    let promoted = 0;
     const results = verdict.results.map((result) => {
         if (!Object.prototype.hasOwnProperty.call(signals, result.lens))
             return result;
         const own = signals[result.lens] ?? [];
+        const rejectLines = context.rejects !== undefined &&
+            Object.prototype.hasOwnProperty.call(context.rejects, result.lens)
+            ? (context.rejects[result.lens] ?? [])
+            : undefined;
         let changed = false;
+        let lensPromoted = 0;
         const findings = result.findings.map((finding) => {
-            if (!finding.blocking || isNone(finding))
+            if (isNone(finding))
                 return finding;
-            if (quotesSignal(`${finding.summary}\n${finding.detail ?? ''}`, own))
+            const text = `${finding.summary}\n${finding.detail ?? ''}`;
+            if (finding.blocking) {
+                if (quotesSignal(text, own, ids))
+                    return finding;
+                changed = true;
+                downgraded++;
+                return { ...finding, blocking: false, summary: `${finding.summary}${DOWNGRADE_NOTE}` };
+            }
+            if (rejectLines === undefined || !quotesSignal(text, rejectLines, ids))
                 return finding;
             changed = true;
-            downgraded++;
-            return { ...finding, blocking: false, summary: `${finding.summary}${DOWNGRADE_NOTE}` };
+            promoted++;
+            lensPromoted++;
+            return { ...finding, blocking: true, summary: `${finding.summary}${PROMOTE_NOTE}` };
         });
         if (!changed)
             return result;
         const outcome = result.outcome === 'rejected' && !hasBlocking(findings)
             ? 'approved'
-            : result.outcome;
-        return { ...result, outcome, findings };
+            : result.outcome === 'approved' && lensPromoted > 0
+                ? 'rejected'
+                : result.outcome;
+        // The lens's own reason text is not regenerated, so a changed word must say who changed it.
+        return {
+            ...result,
+            outcome,
+            findings,
+            ...(outcome === result.outcome ? {} : { tierAdjusted: true }),
+        };
     });
-    if (downgraded === 0)
-        return { verdict, downgraded };
+    if (downgraded === 0 && promoted === 0)
+        return { verdict, downgraded, promoted };
     // Prior-round rulings are carried on each result; the CLI never supplies orphaned ones.
     return {
         verdict: aggregate(verdict.results.map((r) => r.lens), results),
         downgraded,
+        promoted,
     };
 }

package/dist/verdict.d.ts

@@ -30,6 +30,9 @@ export interface LensResult {
     /** Why this lens could not run, or why it found nothing in scope.
      * Meaningless on `approved` and `rejected`. */
     readonly reason?: string;
+    /** True when tier enforcement (tier.ts) changed this lens's outcome after the model gave it,
+     * so the model's own `reason` text no longer matches. Absent otherwise. */
+    readonly tierAdjusted?: boolean;
     /**
      * This lens's own rulings on whichever prior blocking findings were
      * attributed to it (`Subject.priorFindings`, filtered by lens). Present

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verevoir/review",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "The review panel: lens-based diff review. One implementation, consumed by pump-internal review, local preflight, eval-review, and CI.",
   "license": "Apache-2.0",
   "type": "module",

package/src/cli/footer.ts

@@ -46,15 +46,25 @@ export function tierLine(downgraded: number): string | undefined {
     : undefined;
 }
 
+/** The one line saying how many smells tier enforcement promoted to [blocking]; none for 0. */
+export function promotedLine(promoted: number): string | undefined {
+  return promoted > 0
+    ? `Tier: ${String(promoted)} finding(s) promoted: quotes a Reject signal`
+    : undefined;
+}
+
 export function renderFooter(
   requested: string,
   route: RouteName,
   calls: readonly RawCall[],
   downgraded = 0,
+  promoted = 0,
 ): string {
   const lines = ['---', '', `Judged with ${modelText(requested, calls)}, route: ${route}.`];
   const tier = tierLine(downgraded);
   if (tier !== undefined) lines.push('', tier);
+  const promotion = promotedLine(promoted);
+  if (promotion !== undefined) lines.push('', promotion);
   if (calls.length > 0) {
     lines.push('', 'Per-lens usage and wall time:', '');
     for (const call of byLens(calls)) {

package/src/cli/review.ts

@@ -31,7 +31,7 @@ import { buildFileContext, NO_FILE_CONTEXT_NOTE } from '../context-files.js';
 import { buildReferences } from '../references.js';
 import type { DirEntry } from '../references.js';
 import type { RawCall } from '../raw-call.js';
-import { renderFooter, tierLine, usageLines } from './footer.js';
+import { promotedLine, renderFooter, tierLine, usageLines } from './footer.js';
 import type { RouteName } from './footer.js';
 import type { DerivedLenses } from '../practice-lenses.js';
 
@@ -592,14 +592,23 @@ export async function main(
         dedup: parsed.dedup,
         ...(derived === undefined
           ? {}
-          : { tierSignals: derived.signals, practiceNames: derived.practiceNames }),
+          : {
+              tierSignals: derived.signals,
+              tierRejects: derived.rejects,
+              practiceIds: derived.practiceIds,
+              practiceNames: derived.practiceNames,
+            }),
       },
       (call) => void calls.push(call),
     );
     for (const line of usageLines(calls)) io.stderr(line);
     const tier = tierLine(result.downgraded);
     if (tier !== undefined) io.stderr(`${tier}\n`);
-    const footer = `\n\n${renderFooter(model, route, calls, result.downgraded)}`;
+    const promotion = promotedLine(result.promoted);
+    if (promotion !== undefined) io.stderr(`${promotion}\n`);
+    // Audit trail for tier decisions behind merged groups: stderr, not the report (see dedup.ts).
+    for (const line of result.dedupAudit) io.stderr(line);
+    const footer = `\n\n${renderFooter(model, route, calls, result.downgraded, result.promoted)}`;
     const note =
       derived !== undefined && derived.untagged.length > 0
         ? `\n\n> ${String(derived.untagged.length)} practice(s) had no "lens:" tag and were ` +

package/src/dedup.ts

@@ -66,7 +66,8 @@ export function buildDedupPrompt(items: readonly NumberedFinding[]): Prompt {
     'Reply with ONLY a JSON array of arrays of ids, for example ' +
       '[["a:0","b:1"],["a:1"],["b:0"]]. No prose, no markdown fence, no verdict line.',
   ].join('\n');
-  return { shared, perLens };
+  // `cache: false`: no other call reads this `shared`, so a cache write is pure cost.
+  return { shared, perLens, cache: false };
 }
 
 export type GroupsResult =
@@ -148,6 +149,25 @@ export async function dedupFindings(
   return { ok: true, groups };
 }
 
+/**
+ * The audit trail of every MERGED group (two or more members): one stderr line per member, with
+ * its own lens id, tier and text, because the report shows only the highest-tier member's text.
+ * Singletons are not listed: the report already shows them as they are.
+ */
+export function dedupAuditLines(groups: readonly (readonly NumberedFinding[])[]): string[] {
+  const lines: string[] = [];
+  groups.forEach((members, index) => {
+    if (members.length < 2) return;
+    for (const { id, finding } of members) {
+      const text = `${finding.summary} ${finding.detail ?? ''}`.replace(/\s+/g, ' ').trim();
+      lines.push(
+        `dedup group ${String(index + 1)}: ${id} [${finding.blocking ? 'blocking' : 'smell'}] ${text}\n`,
+      );
+    }
+  });
+  return lines;
+}
+
 /**
  * The report view of each group: the highest tier among its members, the text of its highest-tier member (the first blocking one, else the first),
  * and who raised it, naming the practices of each lens that the members' text mentions (by id

package/src/practice-lenses.ts

@@ -47,6 +47,10 @@ export interface DerivedLenses {
    * practices' sensors (label stripped). A [blocking] finding must quote one of these.
    */
   readonly signals: Readonly<Record<string, readonly string[]>>;
+  /** Per lens id: only the `_Reject:_` lines of `signals`. A smell quoting one is promoted. */
+  readonly rejects: Readonly<Record<string, readonly string[]>>;
+  /** Every practice id in the corpus (tagged or not): ignored when matching a quote. */
+  readonly practiceIds: readonly string[];
   /** Per lens id: its practices' ids and H1 titles ('' when none), to name them in a report. */
   readonly practiceNames: Readonly<
     Record<string, readonly { readonly id: string; readonly title: string }[]>
@@ -174,7 +178,7 @@ export function extractSensorHalf(markdown: string): string | undefined {
   return slice.trim();
 }
 
-const SIGNAL_LINE_RE = /^\s*(?:[-*+]\s+)?[_*]{1,2}(?:Reject|Expect):[_*]{1,2}\s*(.*)$/i;
+const SIGNAL_LINE_RE = /^\s*(?:[-*+]\s+)?[_*]{1,2}(Reject|Expect):[_*]{1,2}\s*(.*)$/i;
 const BLOCK_START_RE = /^\s*(?:[-*+]\s|\d+\.\s|#|\*\*)/;
 
 /**
@@ -182,19 +186,27 @@ const BLOCK_START_RE = /^\s*(?:[-*+]\s|\d+\.\s|#|\*\*)/;
  * continuation lines (not a new bullet, heading or bold label) are joined onto their line.
  */
 export function extractSignalLines(sensor: string): string[] {
-  const out: string[] = [];
+  return extractLabelledSignals(sensor).map((s) => s.text);
+}
+
+/** As `extractSignalLines`, keeping which label each line carried. */
+export function extractLabelledSignals(
+  sensor: string,
+): { readonly kind: 'reject' | 'expect'; readonly text: string }[] {
+  const out: { kind: 'reject' | 'expect'; text: string }[] = [];
   const lines = sensor.split(/\r?\n/);
   for (let i = 0; i < lines.length; i++) {
     const match = SIGNAL_LINE_RE.exec(lines[i] ?? '');
     if (match === null) continue;
-    let text = (match[1] ?? '').trim();
+    const kind = (match[1] ?? '').toLowerCase() === 'reject' ? 'reject' : 'expect';
+    let text = (match[2] ?? '').trim();
     while (i + 1 < lines.length) {
       const next = lines[i + 1] ?? '';
       if (next.trim() === '' || !/^\s+\S/.test(next) || BLOCK_START_RE.test(next)) break;
       text = `${text} ${next.trim()}`;
       i++;
     }
-    if (text !== '') out.push(text);
+    if (text !== '') out.push({ kind, text });
   }
   return out;
 }
@@ -216,11 +228,14 @@ export function deriveLensSet(files: readonly PracticeFile[]): DerivedLenses {
     { id: string; title: string | undefined; sensor: string | undefined }[]
   >();
   const signals: Record<string, string[]> = {};
+  const rejects: Record<string, string[]> = {};
+  const practiceIds: string[] = [];
   const practiceNames: Record<string, { id: string; title: string }[]> = {};
   const untagged: string[] = [];
   const missingSensor: string[] = [];
   for (const file of eligible) {
     const id = file.name.slice(0, -'.md'.length);
+    practiceIds.push(id);
     const lensId = parseLensFrontmatter(file.text);
     if (lensId === undefined) {
       untagged.push(id);
@@ -232,7 +247,11 @@ export function deriveLensSet(files: readonly PracticeFile[]): DerivedLenses {
     const title = parseTitle(file.text);
     group.push({ id, title, sensor });
     byLens.set(lensId, group);
-    (signals[lensId] ??= []).push(...(sensor === undefined ? [] : extractSignalLines(sensor)));
+    const labelled = sensor === undefined ? [] : extractLabelledSignals(sensor);
+    (signals[lensId] ??= []).push(...labelled.map((s) => s.text));
+    (rejects[lensId] ??= []).push(
+      ...labelled.filter((s) => s.kind === 'reject').map((s) => s.text),
+    );
     (practiceNames[lensId] ??= []).push({ id, title: title ?? '' });
   }
 
@@ -260,6 +279,8 @@ export function deriveLensSet(files: readonly PracticeFile[]): DerivedLenses {
     untagged,
     missingSensor,
     signals,
+    rejects,
+    practiceIds,
     practiceNames,
   };
 }

package/src/prompt.ts

@@ -144,6 +144,9 @@ export interface Prompt {
   readonly shared: string;
   /** The only part that varies by lens. Goes last. */
   readonly perLens: string;
+  /** `false` for a call whose `shared` no other call reads (the dedup call): a transport that
+   * marks `shared` cacheable must not, as the cache write would never be read. */
+  readonly cache?: false;
 }
 
 /** The two halves in the one order that preserves the shared prefix. */

package/src/report.ts

@@ -72,7 +72,10 @@ function verdictHeading(lens: string, verdict: Verdict): string {
   const result = verdict.results.find((r) => r.lens === lens);
   if (result === undefined) return lens;
   const reason = result.reason === undefined ? '' : result.reason.trim();
-  return reason === '' ? `${lens}: ${result.outcome}` : `${lens}: ${result.outcome}: ${reason}`;
+  // The model's reason was written for the outcome it gave, not the one tier enforcement left.
+  const word =
+    result.tierAdjusted === true ? `${result.outcome} (after tier enforcement)` : result.outcome;
+  return reason === '' ? `${lens}: ${word}` : `${lens}: ${word}: ${reason}`;
 }
 
 export function renderReport(verdict: Verdict, context: ReportContext): string {
@@ -204,19 +207,22 @@ export function renderReport(verdict: Verdict, context: ReportContext): string {
   }
 
   if (verdict.outcome === 'approved') {
+    // What the reader was shown: de-duplicated groups when the findings were merged.
+    const shownSmells =
+      dedup === undefined ? smellCount : dedup.groups.filter((g) => !g.blocking).length;
     const base =
       verdict.outOfScope.length > 0
-        ? smellCount > 0
+        ? shownSmells > 0
           ? 'Every lens with something in scope reviewed it. Nothing it found held this up. See ' +
             'above for the lens(es) that had nothing in scope for this change.'
           : 'Every lens with something in scope reviewed it and found nothing. See above for the ' +
             'lens(es) that had nothing in scope for this change.'
-        : smellCount > 0
+        : shownSmells > 0
           ? 'Every lens reviewed. Nothing it found held this up.'
           : 'Every lens reviewed and none had a finding.';
     const suffix =
-      smellCount > 0
-        ? ` ${smellCount} non-blocking finding(s) are listed above; none of them held this up. ` +
+      shownSmells > 0
+        ? ` ${shownSmells} non-blocking finding(s) are listed above; none of them held this up. ` +
           'If this merges as-is, file each as a follow-up issue before merging, referenced ' +
           'as `owner/repo#123`.'
         : '';

package/src/reviewer-anthropic.ts

@@ -188,7 +188,13 @@ export function anthropicReviewer(
       // The shared half, marked cacheable — `Prompt`'s ordering contract made
       // real: identical bytes for every lens, sent first, so a five-lens
       // panel pays for the diff once.
-      system: [{ type: 'text', text: prompt.shared, cache_control: { type: 'ephemeral' } }],
+      // Unless the prompt says nothing else reads it (`cache: false`): a write nobody reads
+      // is pure cost.
+      system: [
+        prompt.cache === false
+          ? { type: 'text', text: prompt.shared }
+          : { type: 'text', text: prompt.shared, cache_control: { type: 'ephemeral' } },
+      ],
       messages: [{ role: 'user', content: prompt.perLens }],
     });
 

package/src/run-review.ts

@@ -42,7 +42,7 @@ import { describeThrown, type RawCall } from './raw-call.js';
 import { normaliseReviewerReply, type Reviewer } from './panel.js';
 import { warmFirst } from './warm-first.js';
 import { enforceTier } from './tier.js';
-import { dedupFindings, numberFindings, toGroupViews } from './dedup.js';
+import { dedupAuditLines, dedupFindings, numberFindings, toGroupViews } from './dedup.js';
 import type { DedupGroupView } from './report.js';
 
 export type { ReviewAccount } from './review-account.js';
@@ -83,6 +83,10 @@ export interface ReviewNodeInput {
   /** Per lens id: the signal lines its [blocking] findings must quote (see tier.ts). A lens
    * with no entry is left as it was. Absent: no tier enforcement. */
   readonly tierSignals?: Readonly<Record<string, readonly string[]>>;
+  /** Per lens id: just the `_Reject:_` lines of `tierSignals`; a smell quoting one is promoted. */
+  readonly tierRejects?: Readonly<Record<string, readonly string[]>>;
+  /** Every practice id in the corpus; ignored when matching a quote (see tier.ts). */
+  readonly practiceIds?: readonly string[];
   /** After the panel (and tier enforcement), make ONE extra call through the same reviewer to
    * group findings that describe the same defect (see dedup.ts). Off when absent. */
   readonly dedup?: boolean;
@@ -100,6 +104,10 @@ export interface ReviewNodeResult {
   readonly prompts: ReadonlyMap<string, Prompt>;
   /** How many [blocking] findings tier enforcement downgraded to smells (0 when none). */
   readonly downgraded: number;
+  /** How many smells tier enforcement promoted to [blocking] (0 when none). */
+  readonly promoted: number;
+  /** Stderr lines, one per member of every merged dedup group (empty when none merged). */
+  readonly dedupAudit: readonly string[];
 }
 
 // RECORD-NEVER-PREDICT discipline: `onCall` is OPTIONAL so every existing
@@ -190,18 +198,23 @@ export async function runReviewNode(
   // C1 runs before C2: de-duplication sees the tiers as enforced.
   const tiered =
     input.tierSignals === undefined
-      ? { verdict: panel.verdict, downgraded: 0 }
-      : enforceTier(panel.verdict, input.tierSignals);
+      ? { verdict: panel.verdict, downgraded: 0, promoted: 0 }
+      : enforceTier(panel.verdict, input.tierSignals, {
+          ...(input.tierRejects === undefined ? {} : { rejects: input.tierRejects }),
+          ...(input.practiceIds === undefined ? {} : { practiceIds: input.practiceIds }),
+        });
   const verdict = tiered.verdict;
 
   let dedup: { groups: DedupGroupView[]; total: number } | undefined;
   let dedupSkipped: string | undefined;
+  let dedupAudit: readonly string[] = [];
   if (input.dedup === true && verdict.findings.length >= 2) {
     const numbered = numberFindings(verdict.findings);
     // The observed reviewer, outside warm-first: the extra call is recorded like a lens call.
     const outcome = await dedupFindings(numbered, observedReviewer);
     if (outcome.ok) {
       dedup = { groups: toGroupViews(outcome.groups, input.practiceNames), total: numbered.length };
+      dedupAudit = dedupAuditLines(outcome.groups);
     } else {
       dedupSkipped = outcome.reason;
     }
@@ -220,5 +233,7 @@ export async function runReviewNode(
     exitCode: exitCodeFor(verdict.outcome),
     prompts,
     downgraded: tiered.downgraded,
+    promoted: tiered.promoted,
+    dedupAudit,
   };
 }

package/src/tier.ts

@@ -1,7 +1,9 @@
 // Enforces the tier in code. A derived lens is told to tag a finding [blocking] only when it
 // quotes the signal it fails, but a model honours that loosely. After parsing, every [blocking]
 // finding of a derived lens is checked against THAT lens's own practices' `_Reject:_` /
-// `_Expect:_` lines; one that quotes none is downgraded to [smell] and the lens's outcome is
+// `_Expect:_` lines; one that quotes none is downgraded to [smell]. The mirror: a [smell]
+// finding that quotes one of the lens's own `_Reject:_` lines (not `_Expect:_`) is promoted to
+// [blocking], because the bar says a Reject blocks anywhere. The lens's outcome is then
 // recomputed. Deterministic: no model call.
 //
 // MATCHING RULE. Both sides are normalised (lower-cased; markdown emphasis `*` `_` and
@@ -9,6 +11,21 @@
 // finding (summary + detail) quotes a signal line when it contains a contiguous
 // MIN_QUOTE-character (24) run of the signal's normalised text, or the whole normalised line
 // when the line is shorter than that.
+//
+// PRACTICE IDS DO NOT COUNT AS QUOTING. Lens signal lines cross-reference other practices by id
+// (a Reject line may say "see complexity-matches-the-problem"), so a finding that merely NAMES
+// that id would otherwise match 24+ characters without quoting anything. Before matching, every
+// practice id of the corpus (and any backticked kebab-case token) is replaced, in BOTH the
+// signal line and the finding, by a break mark. A run of 24 characters can then never span or
+// consist of an id, and a signal line that is only ids has nothing left to quote. Chosen over
+// "the run must contain a non-id word": stripping is one rule applied to both sides, and it
+// cannot be satisfied by an id plus one filler word.
+//
+// WORD BOUNDARIES. After normalising, every run of characters that are not letters or digits
+// becomes one space, and both sides are padded with a space at each end. So the start or end of
+// a text, and punctuation beside a word, all read as the same single space: a phrase at the
+// start of a finding, after "(", or before ":" matches as it would after a space. The
+// 24-character bar is unchanged; "unpinned/unremarked" is still not "unpinned and unremarked".
 
 import { aggregate } from './verdict.js';
 import type { Finding, LensResult, Verdict } from './verdict.js';
@@ -19,6 +36,9 @@ export const MIN_QUOTE = 24;
 /** Appended to the summary of a finding that was downgraded. */
 export const DOWNGRADE_NOTE = ' (downgraded: no signal quoted)';
 
+/** Appended to the summary of a smell that was promoted. */
+export const PROMOTE_NOTE = ' (promoted: quotes a Reject signal)';
+
 export function normaliseForQuote(text: string): string {
   return text
     .replace(/[*_`]/g, '')
@@ -28,18 +48,65 @@ export function normaliseForQuote(text: string): string {
     .toLowerCase();
 }
 
-/** Whether `text` contains a verbatim quote (per the rule above) of any of `signals`. */
-export function quotesSignal(text: string, signals: readonly string[]): boolean {
-  const haystack = normaliseForQuote(text);
+/** Stands where an id was; survives normalisation and cannot occur in prose. */
+const ID_MARK = '\u0001';
+const BACKTICKED_ID = /`[a-z0-9]+(?:-[a-z0-9]+)+`/g;
+
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function idPattern(ids: readonly string[]): RegExp | undefined {
+  const sorted = [...new Set(ids.map((id) => id.toLowerCase()).filter((id) => id !== ''))].sort(
+    (a, b) => b.length - a.length,
+  );
+  if (sorted.length === 0) return undefined;
+  return new RegExp(`(?<![a-z0-9-])(?:${sorted.map(escapeRegExp).join('|')})(?![a-z0-9-])`, 'g');
+}
+
+function markIds(text: string, pattern: RegExp | undefined): string {
+  const marked = text.toLowerCase().replace(BACKTICKED_ID, ID_MARK);
+  return pattern === undefined ? marked : marked.replace(pattern, ID_MARK);
+}
+
+/** Normalised, punctuation read as a space, padded with a space each end; '' when nothing is left. */
+function boundaryForm(text: string): string {
+  const spaced = normaliseForQuote(text)
+    .replace(/[^\p{L}\p{N}\u0001]+/gu, ' ')
+    .trim();
+  return spaced === '' ? '' : ` ${spaced} `;
+}
+
+/** A 24-character run of `needle` in `haystack`; a needle of 24 or fewer only whole, if allowed. */
+function quotesRun(haystack: string, needle: string, wholeIfShort: boolean): boolean {
+  if (needle === '') return false;
+  if (needle.length <= MIN_QUOTE) return wholeIfShort && haystack.includes(needle);
+  for (let i = 0; i + MIN_QUOTE <= needle.length; i++) {
+    if (haystack.includes(needle.slice(i, i + MIN_QUOTE))) return true;
+  }
+  return false;
+}
+
+/**
+ * Whether `text` contains a verbatim quote (per the rule above) of any of `signals`.
+ * `practiceIds` are the corpus's practice ids, which are ignored on both sides.
+ */
+export function quotesSignal(
+  text: string,
+  signals: readonly string[],
+  practiceIds: readonly string[] = [],
+): boolean {
+  const pattern = idPattern(practiceIds);
+  const haystack = boundaryForm(markIds(text, pattern));
   for (const signal of signals) {
-    const needle = normaliseForQuote(signal);
-    if (needle === '') continue;
-    if (needle.length <= MIN_QUOTE) {
-      if (haystack.includes(needle)) return true;
-      continue;
-    }
-    for (let i = 0; i + MIN_QUOTE <= needle.length; i++) {
-      if (haystack.includes(needle.slice(i, i + MIN_QUOTE))) return true;
+    const marked = markIds(signal, pattern);
+    if (marked.includes(ID_MARK)) {
+      // Each stretch between ids is quoted (or not) on its own; a short one never counts.
+      for (const stretch of marked.split(ID_MARK)) {
+        if (quotesRun(haystack, boundaryForm(stretch), false)) return true;
+      }
+    } else if (quotesRun(haystack, boundaryForm(marked), true)) {
+      return true;
     }
   }
   return false;
@@ -56,42 +123,78 @@ function hasBlocking(findings: readonly Finding[]): boolean {
   return findings.some((f) => f.blocking && !isNone(f));
 }
 
+export interface TierContext {
+  /** Per lens id: just the `_Reject:_` lines. A lens with an entry can have smells promoted. */
+  readonly rejects?: Readonly<Record<string, readonly string[]>>;
+  /** Every practice id in the corpus, ignored when matching. */
+  readonly practiceIds?: readonly string[];
+}
+
 export interface TierResult {
   readonly verdict: Verdict;
   /** How many findings were downgraded. */
   readonly downgraded: number;
+  /** How many smells were promoted to [blocking]. */
+  readonly promoted: number;
 }
 
 /**
- * Downgrade unquoted [blocking] findings of every lens that has an entry in `signals`, then
- * re-aggregate. A lens that was `rejected` and is left with no [blocking] finding counts as
- * `approved`. Lenses without an entry (bundled lenses) are untouched. With nothing to
- * downgrade the verdict is returned as it was.
+ * Downgrade unquoted [blocking] findings of every lens that has an entry in `signals`, promote
+ * smells that quote one of the lens's own Reject lines (`context.rejects`), then re-aggregate.
+ * A lens that was `rejected` and is left with no [blocking] finding counts as `approved`; one
+ * that was `approved` and gained a promoted finding counts as `rejected`; either is marked
+ * `tierAdjusted`. Lenses without an entry (bundled lenses) are untouched. With nothing changed
+ * the verdict is returned as it was.
  */
 export function enforceTier(
   verdict: Verdict,
   signals: Readonly<Record<string, readonly string[]>>,
+  context: TierContext = {},
 ): TierResult {
+  const ids = context.practiceIds ?? [];
   let downgraded = 0;
+  let promoted = 0;
   const results = verdict.results.map((result): LensResult => {
     if (!Object.prototype.hasOwnProperty.call(signals, result.lens)) return result;
     const own = signals[result.lens] ?? [];
+    const rejectLines =
+      context.rejects !== undefined &&
+      Object.prototype.hasOwnProperty.call(context.rejects, result.lens)
+        ? (context.rejects[result.lens] ?? [])
+        : undefined;
     let changed = false;
+    let lensPromoted = 0;
     const findings = result.findings.map((finding): Finding => {
-      if (!finding.blocking || isNone(finding)) return finding;
-      if (quotesSignal(`${finding.summary}\n${finding.detail ?? ''}`, own)) return finding;
+      if (isNone(finding)) return finding;
+      const text = `${finding.summary}\n${finding.detail ?? ''}`;
+      if (finding.blocking) {
+        if (quotesSignal(text, own, ids)) return finding;
+        changed = true;
+        downgraded++;
+        return { ...finding, blocking: false, summary: `${finding.summary}${DOWNGRADE_NOTE}` };
+      }
+      if (rejectLines === undefined || !quotesSignal(text, rejectLines, ids)) return finding;
       changed = true;
-      downgraded++;
-      return { ...finding, blocking: false, summary: `${finding.summary}${DOWNGRADE_NOTE}` };
+      promoted++;
+      lensPromoted++;
+      return { ...finding, blocking: true, summary: `${finding.summary}${PROMOTE_NOTE}` };
     });
     if (!changed) return result;
     const outcome =
       result.outcome === 'rejected' && !hasBlocking(findings)
         ? ('approved' as const)
-        : result.outcome;
-    return { ...result, outcome, findings };
+        : result.outcome === 'approved' && lensPromoted > 0
+          ? ('rejected' as const)
+          : result.outcome;
+    // The lens's own reason text is not regenerated, so a changed word must say who changed it.
+    return {
+      ...result,
+      outcome,
+      findings,
+      ...(outcome === result.outcome ? {} : { tierAdjusted: true }),
+    };
   });
-  if (downgraded === 0) return { verdict, downgraded };
+  if (downgraded === 0 && promoted === 0) return { verdict, downgraded, promoted };
   // Prior-round rulings are carried on each result; the CLI never supplies orphaned ones.
   return {
     verdict: aggregate(
@@ -99,5 +202,6 @@ export function enforceTier(
       results,
     ),
     downgraded,
+    promoted,
   };
 }

package/src/verdict.ts

@@ -90,6 +90,9 @@ export interface LensResult {
   /** Why this lens could not run, or why it found nothing in scope.
    * Meaningless on `approved` and `rejected`. */
   readonly reason?: string;
+  /** True when tier enforcement (tier.ts) changed this lens's outcome after the model gave it,
+   * so the model's own `reason` text no longer matches. Absent otherwise. */
+  readonly tierAdjusted?: boolean;
   /**
    * This lens's own rulings on whichever prior blocking findings were
    * attributed to it (`Subject.priorFindings`, filtered by lens). Present