@verevoir/review 0.3.0 → 0.3.2

package/dist/report.js

@@ -16,6 +16,25 @@ const HEADING = {
     could_not_run: 'Could not run',
     out_of_scope: 'Nothing in scope',
 };
+/** The finding tiers the code knows, most severe first, with their report headings. */
+const TIERS = [
+    { blocking: true, tag: 'blocking', heading: 'Blocking' },
+    { blocking: false, tag: 'smell', heading: 'Smells' },
+];
+/** Code-unit comparison: deterministic across locales, so reruns compare equal. */
+function compareText(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/** Lens count descending, then first lens name, then summary text. */
+function compareGroups(a, b) {
+    return (b.raisedBy.length - a.raisedBy.length ||
+        compareText(a.raisedBy[0]?.lens ?? '', b.raisedBy[0]?.lens ?? '') ||
+        compareText(a.finding.summary, b.finding.summary));
+}
+/** Lens name, then summary text (the --no-dedup order within a tier). */
+function compareFindings(a, b) {
+    return compareText(a.lens, b.lens) || compareText(a.summary, b.summary);
+}
 function raisedByText(view) {
     return view.raisedBy
         .map((r) => (r.practices.length === 0 ? r.lens : `${r.lens} (${r.practices.join(', ')})`))
@@ -49,7 +68,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 = [
@@ -82,17 +103,23 @@ export function renderReport(verdict, context) {
         lines.push(`### ${dedup.groups.length} finding(s)` +
             (smells > 0 ? ` (${blocking} blocking, ${smells} non-blocking)` : '') +
             `, de-duplicated from ${dedup.total} raised`, '');
-        for (const group of dedup.groups) {
-            lines.push(`- [${group.blocking ? 'blocking' : 'smell'}] ${group.finding.summary}`);
-            const detail = group.finding.detail;
-            if (detail !== undefined && detail !== '') {
-                for (const detailLine of detail.split('\n')) {
-                    lines.push(detailLine === '' ? '' : `  ${detailLine}`);
+        for (const tier of TIERS) {
+            const inTier = dedup.groups.filter((g) => g.blocking === tier.blocking).sort(compareGroups);
+            if (inTier.length === 0)
+                continue;
+            lines.push(`### ${tier.heading} (${inTier.length})`, '');
+            for (const group of inTier) {
+                lines.push(`- [${tier.tag}] ${group.finding.summary}`);
+                const detail = group.finding.detail;
+                if (detail !== undefined && detail !== '') {
+                    for (const detailLine of detail.split('\n')) {
+                        lines.push(detailLine === '' ? '' : `  ${detailLine}`);
+                    }
                 }
+                lines.push(`  raised by: ${raisedByText(group)}`);
             }
-            lines.push(`  raised by: ${raisedByText(group)}`);
+            lines.push('');
         }
-        lines.push('');
         // Per-lens verdict lines are unchanged: every lens that reviewed gets its own.
         lines.push('### Lens verdicts', '');
         for (const r of verdict.results) {
@@ -104,25 +131,38 @@ export function renderReport(verdict, context) {
     else if (grouped.size > 0) {
         lines.push(`### ${verdict.findings.length} finding(s)` +
             (smellCount > 0 ? ` (${blockingCount} blocking, ${smellCount} non-blocking)` : ''), '');
-        for (const [lens, findings] of grouped) {
-            lines.push(`#### ${verdictHeading(lens, verdict)}`, '');
-            for (const finding of findings) {
-                lines.push(`- [${finding.blocking ? 'blocking' : 'smell'}] ${finding.summary}`);
+        for (const tier of TIERS) {
+            const inTier = verdict.findings
+                .filter((f) => f.blocking === tier.blocking)
+                .sort(compareFindings);
+            if (inTier.length === 0)
+                continue;
+            lines.push(`### ${tier.heading} (${inTier.length})`, '');
+            for (const finding of inTier) {
+                lines.push(`- [${tier.tag}] ${finding.summary}`);
                 if (finding.detail !== undefined && finding.detail !== '') {
                     for (const detailLine of finding.detail.split('\n')) {
                         lines.push(detailLine === '' ? '' : `  ${detailLine}`);
                     }
                 }
+                lines.push(`  raised by: ${finding.lens}`);
             }
             lines.push('');
         }
+        // Per-lens verdict lines, as in the de-duplicated view: every lens that reviewed.
+        lines.push('### Lens verdicts', '');
+        for (const r of verdict.results) {
+            if (r.outcome === 'approved' || r.outcome === 'rejected') {
+                lines.push(`#### ${verdictHeading(r.lens, verdict)}`, '');
+            }
+        }
     }
     // Every lens gets a line: the approving ones, with no findings, are not otherwise
     // visible. Lenses that did not run or had nothing in scope are listed above.
     const quiet = verdict.results.filter((r) => r.outcome === 'approved' && !grouped.has(r.lens));
-    if (dedup === undefined && quiet.length > 0) {
-        if (grouped.size === 0)
-            lines.push('### Lens verdicts', '');
+    // With findings, the non-dedup branch above already listed every lens's verdict.
+    if (dedup === undefined && grouped.size === 0 && quiet.length > 0) {
+        lines.push('### Lens verdicts', '');
         for (const r of quiet)
             lines.push(`#### ${verdictHeading(r.lens, verdict)}`, '');
     }
@@ -150,17 +190,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.d.ts

@@ -25,6 +25,8 @@ export interface AnthropicReviewerConfig {
      */
     readonly model: string;
     readonly maxTokens: number;
+    /** Sent as `temperature` when present; absent, nothing is sent and the provider default applies. */
+    readonly temperature?: number;
     /** Overridable for tests and for a proxy. */
     readonly baseUrl?: string;
 }

package/dist/reviewer-anthropic.js

@@ -97,10 +97,17 @@ export function anthropicReviewer(config, post, onResolvedModel) {
         const body = JSON.stringify({
             model: config.model,
             max_tokens: config.maxTokens,
+            ...(config.temperature === undefined ? {} : { temperature: config.temperature }),
             // 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/reviewer-selection.d.ts

@@ -21,6 +21,8 @@ export interface SelectReviewerOptions {
     readonly account: ReviewAccount;
     readonly model: string;
     readonly maxTokens: number;
+    /** Sampling temperature for the api route only; the claude-cli route has no such option. */
+    readonly temperature?: number;
     /** Test-only override for the HTTP transport's own `post` — see
      * reviewer-anthropic.ts's `HttpPost`. Defaults to the global `fetch`. */
     readonly post?: HttpPost;

package/dist/reviewer-selection.js

@@ -67,6 +67,7 @@ export function selectReviewer(options) {
                 apiKey: options.account.apiKey,
                 model: resolvedModelId(options.model) ?? options.model,
                 maxTokens: options.maxTokens,
+                ...(options.temperature === undefined ? {} : { temperature: options.temperature }),
             };
             const post = options.post ?? ((url, init) => fetch(url, init));
             return anthropicReviewer(config, post, options.onResolvedModel);

package/dist/run-review.d.ts

@@ -23,6 +23,8 @@ export interface ReviewNodeInput {
      * family alias. */
     readonly model: string;
     readonly maxTokens: number;
+    /** Sampling temperature, sent to every call (lenses and dedup) on the api route; absent sends none. */
+    readonly temperature?: number;
     /** The bar this change is judged against. Optional — its absence is
      * handled by prompt.ts's own `NO_PRACTICES_NOTICE`, not by this file. */
     readonly practices?: string;
@@ -41,6 +43,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 +66,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.
@@ -68,6 +68,7 @@ export async function runReviewNode(input, onCall) {
             account: input.account,
             model: input.model,
             maxTokens: input.maxTokens,
+            ...(input.temperature === undefined ? {} : { temperature: input.temperature }),
             ...(input.post === undefined ? {} : { post: input.post }),
             ...(onCall === undefined
                 ? {}
@@ -116,17 +117,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 +150,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/node_modules/@anthropic-ai/sdk/.github/logo.svg

@@ -0,0 +1,3 @@
+<svg width="248" height="248" viewBox="0 0 248 248" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M52.4285 162.873L98.7844 136.879L99.5485 134.602L98.7844 133.334H96.4921L88.7237 132.862L62.2346 132.153L39.3113 131.207L17.0249 130.026L11.4214 128.844L6.2 121.873L6.7094 118.447L11.4214 115.257L18.171 115.847L33.0711 116.911L55.485 118.447L71.6586 119.392L95.728 121.873H99.5485L100.058 120.337L98.7844 119.392L97.7656 118.447L74.5877 102.732L49.4995 86.1905L36.3823 76.62L29.3779 71.7757L25.8121 67.2858L24.2839 57.3608L30.6515 50.2716L39.3113 50.8623L41.4763 51.4531L50.2636 58.1879L68.9842 72.7209L93.4357 90.6804L97.0015 93.6343L98.4374 92.6652L98.6571 91.9801L97.0015 89.2625L83.757 65.2772L69.621 40.8192L63.2534 30.6579L61.5978 24.632C60.9565 22.1032 60.579 20.0111 60.579 17.4246L67.8381 7.49965L71.9133 6.19995L81.7193 7.49965L85.7946 11.0443L91.9074 24.9865L101.714 46.8451L116.996 76.62L121.453 85.4816L123.873 93.6343L124.764 96.1155H126.292V94.6976L127.566 77.9197L129.858 57.3608L132.15 30.8942L132.915 23.4505L136.608 14.4708L143.994 9.62643L149.725 12.344L154.437 19.0788L153.8 23.4505L150.998 41.6463L145.522 70.1215L141.957 89.2625H143.994L146.414 86.7813L156.093 74.0206L172.266 53.698L179.398 45.6635L187.803 36.802L193.152 32.5484H203.34L210.726 43.6549L207.415 55.1159L196.972 68.3492L188.312 79.5739L175.896 96.2095L168.191 109.585L168.882 110.689L170.738 110.53L198.755 104.504L213.91 101.787L231.994 98.7149L240.144 102.496L241.036 106.395L237.852 114.311L218.495 119.037L195.826 123.645L162.07 131.592L161.696 131.893L162.137 132.547L177.36 133.925L183.855 134.279H199.774L229.447 136.524L237.215 141.605L241.8 147.867L241.036 152.711L229.065 158.737L213.019 154.956L175.45 145.977L162.587 142.787H160.805V143.85L171.502 154.366L191.242 172.089L215.82 195.011L217.094 200.682L213.91 205.172L210.599 204.699L188.949 188.394L180.544 181.069L161.696 165.118H160.422V166.772L164.752 173.152L187.803 207.771L188.949 218.405L187.294 221.832L181.308 223.959L174.813 222.777L161.187 203.754L147.305 182.486L136.098 163.345L134.745 164.2L128.075 235.42L125.019 239.082L117.887 241.8L111.902 237.31L108.718 229.984L111.902 215.452L115.722 196.547L118.779 181.541L121.58 162.873L123.291 156.636L123.14 156.219L121.773 156.449L107.699 175.752L86.304 204.699L69.3663 222.777L65.291 224.431L58.2867 220.768L58.9235 214.27L62.8713 208.48L86.304 178.705L100.44 160.155L109.551 149.507L109.462 147.967L108.959 147.924L46.6977 188.512L35.6182 189.93L30.7788 185.44L31.4156 178.115L33.7079 175.752L52.4285 162.873Z" fill="#D97757"/>
+</svg>