@tokenfactory/acc-runner 0.43.0 → 0.44.1

package/dist/runtime/review-cost-cap.d.ts

@@ -0,0 +1,167 @@
+/**
+ * REV-COST — runner-side per-review cost cap (size-scaled).
+ *
+ * THE EPISODE (PR #1937). The runner reviewer applied the org's FLAT
+ * `max_cost_usd_per_review` and, the instant the spend crossed it, discarded the
+ * review with `cost_cap_exceeded`. #1937 is a ~1800-line PR: it cost ~$18 against
+ * an $8 flat cap and produced NO verdict at all — the money was spent, the
+ * analysis was done, and the harness threw both away, then re-charged the same
+ * review on the next tick. That is the measured 239-decisions-over-9-tasks loop
+ * AU-5 fixed on the SERVER path (api/_lib/cost-cap.ts) and left unfixed here,
+ * which is why a large PR could still be stranded whenever a runner picked the
+ * broadcast up (the normal case — the server path is the emergency fallback).
+ *
+ * This module is the runner's copy of AU-5's PURE cost-cap core:
+ *
+ *   • `effectiveReviewCostCap` — the cap for THIS review, scaled by assembled
+ *     diff size, FLOORED at the org's flat cap (so a median PR is judged against
+ *     exactly today's number — never inflated) and CLAMPED at
+ *     REVIEW_CAP_MAX_MULTIPLE.
+ *   • `foldReviewCostLedger` — the chargeable-vs-infra split. Only PRODUCTIVE
+ *     attempts (a spawn that returned a readable reviewer envelope) are charged
+ *     to the cap; capacity/auth/tooling faults are reported but never charged.
+ *   • `classifyReviewCost` — within / overrun / runaway. `overrun` keeps the
+ *     verdict (the money is already spent; discarding it only strands the PR);
+ *     `runaway` is the hard backstop that still refuses.
+ *
+ * The runner is a standalone published package and cannot import from api/_lib
+ * (the same convention as the duplicated PRICING / MODEL_ALIASES maps and
+ * review-diff-guard.ts). KEEP IN SYNC with the AU-5 block at the bottom of
+ * api/_lib/cost-cap.ts — the constants and all three functions are pinned
+ * byte-for-behaviour by tests/unit/revcost1-runner-cap-parity.test.ts, which
+ * fails the build the moment the two drift.
+ */
+/**
+ * Assembled-diff size the flat cap is treated as calibrated for: the measured
+ * p50 production churn (750 changed lines ≈ 30k chars of unified diff). At or
+ * below this the effective cap is EXACTLY `max_cost_usd_per_review`.
+ * Mirrors api/_lib/cost-cap.ts. // keep in sync
+ */
+export declare const REVIEW_CAP_REFERENCE_DIFF_CHARS = 30000;
+/** Fraction of the base cap added per reference-diff-worth of EXCESS size. */
+export declare const REVIEW_CAP_SIZE_SLOPE = 0.5;
+/**
+ * Ceiling on the scaled cap as a multiple of the base cap. Deliberately tight
+ * (1.5× → $3.00 at a $2 base) because the measured size↔cost correlation is
+ * weak (Pearson r = 0.100): a bigger ramp would be unjustified by the data.
+ */
+export declare const REVIEW_CAP_MAX_MULTIPLE = 1.5;
+/**
+ * Multiple of the effective cap above which an already-PAID review is still
+ * discarded as a runaway — the hard backstop that survives this change. Between
+ * 1× and this, the verdict is KEPT and flagged (`cost_overrun`) instead of
+ * stranding the PR.
+ */
+export declare const REVIEW_COST_OVERRUN_TOLERANCE = 3;
+export interface ReviewCostCapDecision {
+    /** The cap to enforce for THIS review. */
+    cap_usd: number;
+    /** The org's flat `max_cost_usd_per_review` — the floor. */
+    base_cap_usd: number;
+    /** false when the base cap is 0/negative/non-finite (cap disabled). */
+    enabled: boolean;
+    /** Assembled-diff chars the scale was computed from. */
+    diff_chars: number;
+    /** cap_usd / base_cap_usd — 1 when the flat floor applied. */
+    scale: number;
+    /** True when the size ramp hit REVIEW_CAP_MAX_MULTIPLE. */
+    ceiling_applied: boolean;
+    /** Spend above which an already-paid verdict is discarded as a runaway. */
+    runaway_usd: number;
+}
+/**
+ * The size-scaled per-review cost cap. Monotone non-decreasing in `diffChars`,
+ * floored at `baseCapUsd` (so it can only ever LOOSEN relative to the flat cap —
+ * a small PR's effective cap is unchanged) and clamped at
+ * `REVIEW_CAP_MAX_MULTIPLE × baseCapUsd`. Pure.
+ *
+ * A base cap of 0 (or a non-finite/negative one) means "cap disabled" — the
+ * existing `max_cost_usd_per_review > 0` semantics — and is returned verbatim.
+ *
+ * Mirrors api/_lib/cost-cap.ts `effectiveReviewCostCap`. // keep in sync
+ */
+export declare function effectiveReviewCostCap(baseCapUsd: number, diffChars: number): ReviewCostCapDecision;
+/**
+ * How one reviewer attempt is classified for BUDGET purposes. Only `productive`
+ * attempts (a spawn that returned a reviewer envelope we can read a verdict out
+ * of) are charged to the per-review cap. Every other class is an INFRA fault: it
+ * is still reported in the review's total spend so the accounting stays honest,
+ * but it must never consume the budget set aside for reviewing this PR.
+ *
+ * Mirrors api/_lib/cost-cap.ts `ReviewAttemptClass`. // keep in sync
+ */
+export type ReviewAttemptClass = "productive"
+/** Parse-repair re-prompt — a harness cost, not review work. */
+ | "parse_repair"
+/** 429 / overloaded / rate-limit brownout (budget-exempt). */
+ | "infra_capacity"
+/** Hard billing/quota wall. */
+ | "infra_billing"
+/** Account-level spend cap. */
+ | "infra_billing_capped"
+/** Missing/invalid credential — env broken. */
+ | "infra_auth"
+/** Verification-tooling failure (unread file / truncated diff). */
+ | "infra_tooling";
+export interface ReviewCostAttempt {
+    /** 1-based attempt ordinal within this review. */
+    attempt: number;
+    model_id: string;
+    attempt_class: ReviewAttemptClass;
+    /** Spend this attempt actually incurred (0 for a throw before any tokens). */
+    cost_usd: number;
+}
+export interface ReviewCostLedger {
+    attempts: ReviewCostAttempt[];
+    /** Sum of PRODUCTIVE attempt cost — the only figure the cap is checked against. */
+    chargeable_usd: number;
+    /** Sum of every non-productive attempt cost (reported, never charged). */
+    infra_usd: number;
+    /** chargeable + infra — what the review truly cost (stored on the queue row). */
+    total_usd: number;
+    productive_attempts: number;
+    infra_attempts: number;
+}
+/**
+ * Fold an attempt list into the chargeable / infra split. Pure.
+ * Mirrors api/_lib/cost-cap.ts `foldReviewCostLedger`. // keep in sync
+ */
+export declare function foldReviewCostLedger(attempts: ReviewCostAttempt[]): ReviewCostLedger;
+/**
+ * Verdict on this review's chargeable spend:
+ *   • `within`  — at or under the effective cap. Nothing changes.
+ *   • `overrun` — over the cap but under the runaway threshold. The money is
+ *     ALREADY SPENT, so discarding the verdict buys nothing and strands the PR
+ *     (#1937). Keep the verdict and flag it.
+ *   • `runaway` — past the tolerance band. Refuse the verdict; something is
+ *     pathological and the operator must see it.
+ *
+ * Mirrors api/_lib/cost-cap.ts `classifyReviewCost`. // keep in sync
+ */
+export type ReviewCostVerdict = "within" | "overrun" | "runaway";
+export declare function classifyReviewCost(chargeableUsd: number, cap: ReviewCostCapDecision): ReviewCostVerdict;
+/** Mutable cost state for ONE review, shared by every pass it runs. */
+export interface ReviewCostContext {
+    cap: ReviewCostCapDecision;
+    attempts: ReviewCostAttempt[];
+}
+/** Open a cost context for a review over `diffChars` of assembled diff. */
+export declare function openReviewCostContext(baseCapUsd: number, diffChars: number): ReviewCostContext;
+/** Record one attempt and return the folded ledger. */
+export declare function chargeReviewAttempt(ctx: ReviewCostContext, modelId: string, attemptClass: ReviewAttemptClass, costUsd: number): ReviewCostLedger;
+/** The current folded ledger without recording anything. */
+export declare function reviewCostLedger(ctx: ReviewCostContext): ReviewCostLedger;
+/**
+ * Advisory reason for an ACCEPTED overrun. Deliberately phrased to match none of
+ * the absence-claim patterns in review-chunking.ts (asserted by this wave's
+ * test), so an audit line can never be re-read as a read-coverage claim.
+ */
+export declare function reviewCostOverrunReason(cap: ReviewCostCapDecision, ledger: ReviewCostLedger): string;
+/**
+ * Refusal reason for a RUNAWAY — the backstop above the scaled cap. Carries the
+ * PRODUCTIVE attempt count, which is what distinguishes a single-pass runaway
+ * from a chunked review that accumulated past the tolerance over several part
+ * passes (the old chunked-only reason string), without needing two call sites.
+ */
+export declare function reviewCostRunawayReason(cap: ReviewCostCapDecision, ledger: ReviewCostLedger): string;
+//# sourceMappingURL=review-cost-cap.d.ts.map

package/dist/runtime/review-cost-cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-cost-cap.d.ts","sourceRoot":"","sources":["../../src/runtime/review-cost-cap.ts"],"names":[],"mappings":"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"}

package/dist/runtime/review-cost-cap.js

@@ -0,0 +1,182 @@
+/**
+ * REV-COST — runner-side per-review cost cap (size-scaled).
+ *
+ * THE EPISODE (PR #1937). The runner reviewer applied the org's FLAT
+ * `max_cost_usd_per_review` and, the instant the spend crossed it, discarded the
+ * review with `cost_cap_exceeded`. #1937 is a ~1800-line PR: it cost ~$18 against
+ * an $8 flat cap and produced NO verdict at all — the money was spent, the
+ * analysis was done, and the harness threw both away, then re-charged the same
+ * review on the next tick. That is the measured 239-decisions-over-9-tasks loop
+ * AU-5 fixed on the SERVER path (api/_lib/cost-cap.ts) and left unfixed here,
+ * which is why a large PR could still be stranded whenever a runner picked the
+ * broadcast up (the normal case — the server path is the emergency fallback).
+ *
+ * This module is the runner's copy of AU-5's PURE cost-cap core:
+ *
+ *   • `effectiveReviewCostCap` — the cap for THIS review, scaled by assembled
+ *     diff size, FLOORED at the org's flat cap (so a median PR is judged against
+ *     exactly today's number — never inflated) and CLAMPED at
+ *     REVIEW_CAP_MAX_MULTIPLE.
+ *   • `foldReviewCostLedger` — the chargeable-vs-infra split. Only PRODUCTIVE
+ *     attempts (a spawn that returned a readable reviewer envelope) are charged
+ *     to the cap; capacity/auth/tooling faults are reported but never charged.
+ *   • `classifyReviewCost` — within / overrun / runaway. `overrun` keeps the
+ *     verdict (the money is already spent; discarding it only strands the PR);
+ *     `runaway` is the hard backstop that still refuses.
+ *
+ * The runner is a standalone published package and cannot import from api/_lib
+ * (the same convention as the duplicated PRICING / MODEL_ALIASES maps and
+ * review-diff-guard.ts). KEEP IN SYNC with the AU-5 block at the bottom of
+ * api/_lib/cost-cap.ts — the constants and all three functions are pinned
+ * byte-for-behaviour by tests/unit/revcost1-runner-cap-parity.test.ts, which
+ * fails the build the moment the two drift.
+ */
+/**
+ * Assembled-diff size the flat cap is treated as calibrated for: the measured
+ * p50 production churn (750 changed lines ≈ 30k chars of unified diff). At or
+ * below this the effective cap is EXACTLY `max_cost_usd_per_review`.
+ * Mirrors api/_lib/cost-cap.ts. // keep in sync
+ */
+export const REVIEW_CAP_REFERENCE_DIFF_CHARS = 30_000;
+/** Fraction of the base cap added per reference-diff-worth of EXCESS size. */
+export const REVIEW_CAP_SIZE_SLOPE = 0.5;
+/**
+ * Ceiling on the scaled cap as a multiple of the base cap. Deliberately tight
+ * (1.5× → $3.00 at a $2 base) because the measured size↔cost correlation is
+ * weak (Pearson r = 0.100): a bigger ramp would be unjustified by the data.
+ */
+export const REVIEW_CAP_MAX_MULTIPLE = 1.5;
+/**
+ * Multiple of the effective cap above which an already-PAID review is still
+ * discarded as a runaway — the hard backstop that survives this change. Between
+ * 1× and this, the verdict is KEPT and flagged (`cost_overrun`) instead of
+ * stranding the PR.
+ */
+export const REVIEW_COST_OVERRUN_TOLERANCE = 3;
+/**
+ * The size-scaled per-review cost cap. Monotone non-decreasing in `diffChars`,
+ * floored at `baseCapUsd` (so it can only ever LOOSEN relative to the flat cap —
+ * a small PR's effective cap is unchanged) and clamped at
+ * `REVIEW_CAP_MAX_MULTIPLE × baseCapUsd`. Pure.
+ *
+ * A base cap of 0 (or a non-finite/negative one) means "cap disabled" — the
+ * existing `max_cost_usd_per_review > 0` semantics — and is returned verbatim.
+ *
+ * Mirrors api/_lib/cost-cap.ts `effectiveReviewCostCap`. // keep in sync
+ */
+export function effectiveReviewCostCap(baseCapUsd, diffChars) {
+    const base = typeof baseCapUsd === "number" && Number.isFinite(baseCapUsd) && baseCapUsd > 0
+        ? baseCapUsd
+        : 0;
+    const chars = typeof diffChars === "number" && Number.isFinite(diffChars) && diffChars > 0
+        ? diffChars
+        : 0;
+    if (base === 0) {
+        return {
+            cap_usd: 0,
+            base_cap_usd: 0,
+            enabled: false,
+            diff_chars: chars,
+            scale: 1,
+            ceiling_applied: false,
+            runaway_usd: 0,
+        };
+    }
+    const excess = Math.max(0, chars - REVIEW_CAP_REFERENCE_DIFF_CHARS);
+    const raw = 1 + (REVIEW_CAP_SIZE_SLOPE * excess) / REVIEW_CAP_REFERENCE_DIFF_CHARS;
+    const scale = Math.min(raw, REVIEW_CAP_MAX_MULTIPLE);
+    const cap = base * scale;
+    return {
+        cap_usd: cap,
+        base_cap_usd: base,
+        enabled: true,
+        diff_chars: chars,
+        scale,
+        ceiling_applied: raw > REVIEW_CAP_MAX_MULTIPLE,
+        runaway_usd: cap * REVIEW_COST_OVERRUN_TOLERANCE,
+    };
+}
+function usableUsd(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+/**
+ * Fold an attempt list into the chargeable / infra split. Pure.
+ * Mirrors api/_lib/cost-cap.ts `foldReviewCostLedger`. // keep in sync
+ */
+export function foldReviewCostLedger(attempts) {
+    let chargeable = 0;
+    let infra = 0;
+    let productiveN = 0;
+    let infraN = 0;
+    for (const a of attempts) {
+        const cost = usableUsd(a.cost_usd);
+        if (a.attempt_class === "productive") {
+            chargeable += cost;
+            productiveN += 1;
+        }
+        else {
+            infra += cost;
+            infraN += 1;
+        }
+    }
+    return {
+        attempts,
+        chargeable_usd: chargeable,
+        infra_usd: infra,
+        total_usd: chargeable + infra,
+        productive_attempts: productiveN,
+        infra_attempts: infraN,
+    };
+}
+export function classifyReviewCost(chargeableUsd, cap) {
+    if (!cap.enabled)
+        return "within";
+    const spent = usableUsd(chargeableUsd);
+    if (spent <= cap.cap_usd)
+        return "within";
+    return spent > cap.runaway_usd ? "runaway" : "overrun";
+}
+/** Open a cost context for a review over `diffChars` of assembled diff. */
+export function openReviewCostContext(baseCapUsd, diffChars) {
+    return { cap: effectiveReviewCostCap(baseCapUsd, diffChars), attempts: [] };
+}
+/** Record one attempt and return the folded ledger. */
+export function chargeReviewAttempt(ctx, modelId, attemptClass, costUsd) {
+    ctx.attempts.push({
+        attempt: ctx.attempts.length + 1,
+        model_id: modelId,
+        attempt_class: attemptClass,
+        cost_usd: costUsd,
+    });
+    return foldReviewCostLedger(ctx.attempts);
+}
+/** The current folded ledger without recording anything. */
+export function reviewCostLedger(ctx) {
+    return foldReviewCostLedger(ctx.attempts);
+}
+/**
+ * Advisory reason for an ACCEPTED overrun. Deliberately phrased to match none of
+ * the absence-claim patterns in review-chunking.ts (asserted by this wave's
+ * test), so an audit line can never be re-read as a read-coverage claim.
+ */
+export function reviewCostOverrunReason(cap, ledger) {
+    return (`cost_overrun: review cost $${ledger.chargeable_usd.toFixed(4)} exceeded the ` +
+        `effective cap $${cap.cap_usd.toFixed(2)} (base $${cap.base_cap_usd.toFixed(2)}, ` +
+        `scale ${cap.scale.toFixed(2)}×, ${cap.diff_chars} chars of assembled changes) — ` +
+        `verdict KEPT (already paid) and escalated for cap ratification`);
+}
+/**
+ * Refusal reason for a RUNAWAY — the backstop above the scaled cap. Carries the
+ * PRODUCTIVE attempt count, which is what distinguishes a single-pass runaway
+ * from a chunked review that accumulated past the tolerance over several part
+ * passes (the old chunked-only reason string), without needing two call sites.
+ */
+export function reviewCostRunawayReason(cap, ledger) {
+    const n = ledger.productive_attempts;
+    return (`reviewer cost $${ledger.chargeable_usd.toFixed(4)} across ${n} productive ` +
+        `${n === 1 ? "attempt" : "attempts"} exceeded cap $${cap.cap_usd.toFixed(2)} ` +
+        `(base $${cap.base_cap_usd.toFixed(2)}, scale ${cap.scale.toFixed(2)}×) by more ` +
+        `than the ${REVIEW_COST_OVERRUN_TOLERANCE}× runaway tolerance ` +
+        `($${cap.runaway_usd.toFixed(2)}) — verdict refused`);
+}
+//# sourceMappingURL=review-cost-cap.js.map

package/dist/runtime/review-cost-cap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-cost-cap.js","sourceRoot":"","sources":["../../src/runtime/review-cost-cap.ts"],"names":[],"mappings":"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"}

package/dist/runtime/reviewer-abstain.d.ts

@@ -0,0 +1,101 @@
+/**
+ * S15-FU/REVIEW-1 (AC2) — reviewer FAULT ⇒ explicit abstain, never a verdict.
+ *
+ * THE RULE. A reviewer fault is a statement about the HARNESS, not about the
+ * code. When the reviewer cannot render a faithful prompt, cannot parse its own
+ * output, or cites content it never actually read, the only sound outcome is
+ * "I did not review this — a human must": an explicit ABSTAIN that routes the PR
+ * to needs-review. It must NEVER be a confident reject, and it must never carry
+ * a defect reason, because on a fault path there is no evidence for one.
+ *
+ * WHY THIS MODULE EXISTS. The #1933 episode produced 0.75–0.85-confidence
+ * rejects naming a "prose spliced into the SQL literal" corruption that did not
+ * exist — the reviewer was reporting, in good faith, the harness's own prompt
+ * text that a `replace()` bug had spliced into the diff (see
+ * `./prompt-substitute.ts`). Two of those sessions even self-logged the fault and
+ * still emitted a reject. Fixing the splice (AC1) removes THAT trigger; this
+ * module removes the whole CLASS, by making every fault path structurally
+ * incapable of producing a defect claim.
+ *
+ * MECHANISM, and why the decision string is unchanged. `decision` stays
+ * `reviewer_error`, which downstream ALREADY treats as "never merges, retry or
+ * hold" — introducing a new decision value would silently fall through every
+ * classifier that switches on it. What is new is that the outcome is explicitly
+ * MARKED as an abstain, its confidence is pinned to 0, and any model-authored
+ * text is QUARANTINED behind a prefix that the finding classifiers skip, so it
+ * can be read as context by an operator and never scored as a defect.
+ *
+ * Pure. No I/O, no DB, no throw.
+ * Mirrored from `api/_lib/reviewer/abstain.ts`; the runner ships as a published
+ * npm package and cannot import from `api/_lib`.
+ * // keep in sync with api/_lib/reviewer/abstain.ts
+ */
+/** What faulted. Recorded verbatim on the outcome so the trail is diagnosable. */
+export type ReviewerFaultKind = 
+/** The rendered prompt did not carry the PR content verbatim (#1933 class). */
+"prompt_render"
+/** The reviewer's own JSON verdict could not be parsed, even after repair. */
+ | "verdict_parse"
+/** The CLI/API envelope around the verdict could not be parsed. */
+ | "envelope_parse"
+/** The verdict cited a file/diff the verification tooling never read (RR-3). */
+ | "tooling_read";
+/**
+ * Stable marker for cheap row detection — mirrors TOOLING_FAILURE_MARKER /
+ * ACCOUNT_CAP_MARKER in `api/_lib/review-retry.ts`, so ONLY rows we classified
+ * are ever treated as abstentions.
+ */
+export declare const REVIEWER_ABSTAIN_MARKER = "reviewer abstained:";
+/** The headline stamped on every abstain outcome. Explicit by design: an
+ *  operator reading the row must not have to infer that nothing was judged. */
+export declare const REVIEWER_ABSTAIN_REASON: string;
+/**
+ * Prefix applied to every model-authored / fault-detail line carried alongside an
+ * abstain. Deliberately leads with "advisory" so the RR-3 severity classifiers
+ * and the calibration reason-matchers read it as non-blocking context.
+ */
+export declare const ABSTAIN_DETAIL_PREFIX = "abstain_context (advisory, not a finding):";
+/** A one-line, machine-greppable statement of which fault kind fired. */
+export declare function abstainFaultLine(kind: ReviewerFaultKind): string;
+/**
+ * Quarantine fault detail behind ABSTAIN_DETAIL_PREFIX. Empty/blank lines are
+ * dropped, each line is capped, and the list is bounded so a runaway model
+ * response cannot bloat the stored row.
+ */
+export declare function quarantineAbstainDetail(lines: ReadonlyArray<string | null | undefined>, opts?: {
+    maxLines?: number;
+    maxChars?: number;
+}): string[];
+/**
+ * The full `reasons` array for an abstain outcome: the explicit headline, the
+ * fault kind, then quarantined detail. Callers pin `confidence: 0` and keep
+ * `decision: 'reviewer_error'`.
+ */
+export declare function abstainReasons(kind: ReviewerFaultKind, detail?: ReadonlyArray<string | null | undefined>): string[];
+/**
+ * A short operator-facing stderr line for an abstain. Names the fault kind and
+ * the abstain routing, never the model's text (which may be corrupted content).
+ */
+export declare function describeAbstainForLog(kind: ReviewerFaultKind, detail?: string): string;
+/**
+ * True when a completed review outcome/row is an ABSTAIN. Marker-based and
+ * defensive: a non-`reviewer_error` decision or absent reasons ⇒ false, so a
+ * legacy row that merely mentions abstaining is never reclassified.
+ */
+export declare function isAbstainReviewerOutcome(decision: string | null | undefined, reasons: string[] | null | undefined): boolean;
+/**
+ * Reason prefixes that are STRUCTURAL — emitted by the harness, describing the
+ * review itself rather than the code. Anything not in this set is a finding.
+ *
+ * `"review diff coverage:"` is REVIEW_DIFF_COVERAGE_MARKER from
+ * `./absence-claims.ts`; it is inlined (and pinned by a test) so this module
+ * stays dependency-free and trivially mirrorable into the runner package.
+ */
+export declare const ABSTAIN_STRUCTURAL_PREFIXES: readonly string[];
+/**
+ * True when `reasons` carries NO unquarantined, model-authored finding — the
+ * invariant an abstain must satisfy. Used by the AC2 test to prove that a
+ * simulated fault cannot smuggle a fabricated defect reason through.
+ */
+export declare function abstainCarriesNoFinding(reasons: string[] | null | undefined): boolean;
+//# sourceMappingURL=reviewer-abstain.d.ts.map

package/dist/runtime/reviewer-abstain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewer-abstain.d.ts","sourceRoot":"","sources":["../../src/runtime/reviewer-abstain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,kFAAkF;AAClF,MAAM,MAAM,iBAAiB;AAC3B,+EAA+E;AAC7E,eAAe;AACjB,8EAA8E;GAC5E,eAAe;AACjB,mEAAmE;GACjE,gBAAgB;AAClB,gFAAgF;GAC9E,cAAc,CAAC;AAEnB;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAE7D;+EAC+E;AAC/E,eAAO,MAAM,uBAAuB,QAI2C,CAAC;AAEhF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,+CAA+C,CAAC;AAElF,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,aAAa,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAC/C,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClD,MAAM,EAAE,CAeV;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,iBAAiB,EACvB,MAAM,GAAE,aAAa,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAM,GACpD,MAAM,EAAE,CAMV;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,iBAAiB,EACvB,MAAM,GAAE,MAAW,GAClB,MAAM,CAMR;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,GACnC,OAAO,CAKT;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,SAAS,MAAM,EAOxD,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAMrF"}

package/dist/runtime/reviewer-abstain.js

@@ -0,0 +1,138 @@
+/**
+ * S15-FU/REVIEW-1 (AC2) — reviewer FAULT ⇒ explicit abstain, never a verdict.
+ *
+ * THE RULE. A reviewer fault is a statement about the HARNESS, not about the
+ * code. When the reviewer cannot render a faithful prompt, cannot parse its own
+ * output, or cites content it never actually read, the only sound outcome is
+ * "I did not review this — a human must": an explicit ABSTAIN that routes the PR
+ * to needs-review. It must NEVER be a confident reject, and it must never carry
+ * a defect reason, because on a fault path there is no evidence for one.
+ *
+ * WHY THIS MODULE EXISTS. The #1933 episode produced 0.75–0.85-confidence
+ * rejects naming a "prose spliced into the SQL literal" corruption that did not
+ * exist — the reviewer was reporting, in good faith, the harness's own prompt
+ * text that a `replace()` bug had spliced into the diff (see
+ * `./prompt-substitute.ts`). Two of those sessions even self-logged the fault and
+ * still emitted a reject. Fixing the splice (AC1) removes THAT trigger; this
+ * module removes the whole CLASS, by making every fault path structurally
+ * incapable of producing a defect claim.
+ *
+ * MECHANISM, and why the decision string is unchanged. `decision` stays
+ * `reviewer_error`, which downstream ALREADY treats as "never merges, retry or
+ * hold" — introducing a new decision value would silently fall through every
+ * classifier that switches on it. What is new is that the outcome is explicitly
+ * MARKED as an abstain, its confidence is pinned to 0, and any model-authored
+ * text is QUARANTINED behind a prefix that the finding classifiers skip, so it
+ * can be read as context by an operator and never scored as a defect.
+ *
+ * Pure. No I/O, no DB, no throw.
+ * Mirrored from `api/_lib/reviewer/abstain.ts`; the runner ships as a published
+ * npm package and cannot import from `api/_lib`.
+ * // keep in sync with api/_lib/reviewer/abstain.ts
+ */
+/**
+ * Stable marker for cheap row detection — mirrors TOOLING_FAILURE_MARKER /
+ * ACCOUNT_CAP_MARKER in `api/_lib/review-retry.ts`, so ONLY rows we classified
+ * are ever treated as abstentions.
+ */
+export const REVIEWER_ABSTAIN_MARKER = "reviewer abstained:";
+/** The headline stamped on every abstain outcome. Explicit by design: an
+ *  operator reading the row must not have to infer that nothing was judged. */
+export const REVIEWER_ABSTAIN_REASON = `${REVIEWER_ABSTAIN_MARKER} the reviewer harness faulted, so NO code judgement ` +
+    "was formed — this is NOT a defect finding and NOT a reject. The PR needs " +
+    "HUMAN VERIFICATION: route to needs-review and have an operator read the diff. " +
+    "Any reviewer text below is quarantined diagnostic context, never a finding.";
+/**
+ * Prefix applied to every model-authored / fault-detail line carried alongside an
+ * abstain. Deliberately leads with "advisory" so the RR-3 severity classifiers
+ * and the calibration reason-matchers read it as non-blocking context.
+ */
+export const ABSTAIN_DETAIL_PREFIX = "abstain_context (advisory, not a finding):";
+/** A one-line, machine-greppable statement of which fault kind fired. */
+export function abstainFaultLine(kind) {
+    return `abstain_fault_kind: ${kind}`;
+}
+/**
+ * Quarantine fault detail behind ABSTAIN_DETAIL_PREFIX. Empty/blank lines are
+ * dropped, each line is capped, and the list is bounded so a runaway model
+ * response cannot bloat the stored row.
+ */
+export function quarantineAbstainDetail(lines, opts = {}) {
+    const maxLines = opts.maxLines ?? 6;
+    const maxChars = opts.maxChars ?? 300;
+    const out = [];
+    for (const raw of lines ?? []) {
+        const text = (raw ?? "").trim();
+        if (!text)
+            continue;
+        // Already quarantined (or already the headline) → pass through untouched.
+        const prefixed = text.startsWith(ABSTAIN_DETAIL_PREFIX) || text.startsWith(REVIEWER_ABSTAIN_MARKER)
+            ? text
+            : `${ABSTAIN_DETAIL_PREFIX} ${text}`;
+        out.push(prefixed.slice(0, maxChars));
+        if (out.length >= maxLines)
+            break;
+    }
+    return out;
+}
+/**
+ * The full `reasons` array for an abstain outcome: the explicit headline, the
+ * fault kind, then quarantined detail. Callers pin `confidence: 0` and keep
+ * `decision: 'reviewer_error'`.
+ */
+export function abstainReasons(kind, detail = []) {
+    return [
+        REVIEWER_ABSTAIN_REASON,
+        abstainFaultLine(kind),
+        ...quarantineAbstainDetail(detail),
+    ];
+}
+/**
+ * A short operator-facing stderr line for an abstain. Names the fault kind and
+ * the abstain routing, never the model's text (which may be corrupted content).
+ */
+export function describeAbstainForLog(kind, detail = "") {
+    const tail = detail.trim() ? ` — ${detail.trim().slice(0, 200)}` : "";
+    return (`[reviewer] ABSTAIN (${kind}): harness fault, no code judgement formed; ` +
+        `routing to needs-review for human verification${tail}\n`);
+}
+/**
+ * True when a completed review outcome/row is an ABSTAIN. Marker-based and
+ * defensive: a non-`reviewer_error` decision or absent reasons ⇒ false, so a
+ * legacy row that merely mentions abstaining is never reclassified.
+ */
+export function isAbstainReviewerOutcome(decision, reasons) {
+    if (decision !== "reviewer_error")
+        return false;
+    return (reasons ?? []).some((r) => typeof r === "string" && r.includes(REVIEWER_ABSTAIN_MARKER));
+}
+/**
+ * Reason prefixes that are STRUCTURAL — emitted by the harness, describing the
+ * review itself rather than the code. Anything not in this set is a finding.
+ *
+ * `"review diff coverage:"` is REVIEW_DIFF_COVERAGE_MARKER from
+ * `./absence-claims.ts`; it is inlined (and pinned by a test) so this module
+ * stays dependency-free and trivially mirrorable into the runner package.
+ */
+export const ABSTAIN_STRUCTURAL_PREFIXES = [
+    REVIEWER_ABSTAIN_MARKER,
+    ABSTAIN_DETAIL_PREFIX,
+    "abstain_fault_kind:",
+    // Read-coverage telemetry stamped on every outcome: it states how MUCH was
+    // read, never what is wrong. // keep in sync with REVIEW_DIFF_COVERAGE_MARKER
+    "review diff coverage:",
+];
+/**
+ * True when `reasons` carries NO unquarantined, model-authored finding — the
+ * invariant an abstain must satisfy. Used by the AC2 test to prove that a
+ * simulated fault cannot smuggle a fabricated defect reason through.
+ */
+export function abstainCarriesNoFinding(reasons) {
+    return (reasons ?? []).every((r) => {
+        const text = (r ?? "").trim();
+        if (!text)
+            return true;
+        return ABSTAIN_STRUCTURAL_PREFIXES.some((p) => text.startsWith(p));
+    });
+}
+//# sourceMappingURL=reviewer-abstain.js.map

package/dist/runtime/reviewer-abstain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewer-abstain.js","sourceRoot":"","sources":["../../src/runtime/reviewer-abstain.ts"],"names":[],"mappings":"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"}