argus-reviewer-e2e 0.1.3 → 0.3.0

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+import type { Trust } from './trust.js';
 export interface ProviderRules {
     only?: string[];
     ignore?: string[];
@@ -59,6 +60,13 @@ export interface Config {
      * PR diffs and post findings. Defaults to the primary `model` if not set.
      */
     code_model: string | undefined;
+    /**
+     * OpenRouter Decisions API model for typed adjudication (Jev). Defaults
+     * to the pinned `typesafe/jev-1.13-20260917` — alias slugs like
+     * `~typesafe/jev-latest` drift silently and thresholds are calibrated
+     * to a version. Set to `''` to disable adjudication (regex-only mode).
+     */
+    decisionModel: string | undefined;
     /**
      * Hard budget for the `argus-reviewer code-review` lane. When set, the
      * review stops early if the cumulative OpenRouter cost exceeds this cap.
@@ -152,16 +160,73 @@ export interface Config {
      * `resolveConfig` — `enabled: false` by default so the lane is opt-in.
      */
     sandbox: Sandbox;
+    /**
+     * Code-review policy knobs. Always populated after `resolveConfig`.
+     * `secretsThreshold`: Jev `noul` probability at/above which a
+     * secret-shaped diff literal is reported as a finding (below →
+     * suppressed but audit-recorded). Default 0.3 — tune after dogfooding.
+     * `maxComments`: cap on inline review comments posted per run
+     * (default 20) — overflow is summarized count-only in the sticky.
+     * `severityGate`: consumer-facing alias over `severity` — 'bug'
+     * fails on bugs only, 'risk' fails on bug|risk. Unset → `severity`
+     * list is authoritative.
+     * `triage`: Jev pre-review lane — 'off' no call, 'annotate' (default)
+     * records risk/deep-review/area into the report + sticky, 'route'
+     * additionally swaps the code model to `lowRiskModel` on low-risk
+     * diffs. Jev routes/annotates, never gates — coverage is constant.
+     * `lowRiskModel`: the cheap code-model slug 'route' falls to; unset →
+     * route keeps `code_model` (annotate-equivalent).
+     * `findingThreshold`: P(false-positive) required to suppress a nit/q
+     * finding after Jev adjudication — 1.0 (default) is annotate-only,
+     * lowering it suppresses progressively more low-confidence nits.
+     * bug/risk are never suppressed.
+     * `requestChanges`: allow the review event to escalate to
+     * REQUEST_CHANGES for proven blockers (probe-reproduced or Jev
+     * high-confidence). Default true — set false for advisory-only posting.
+     */
+    review: {
+        secretsThreshold: number;
+        maxComments: number;
+        severityGate: 'bug' | 'risk' | undefined;
+        triage: 'off' | 'annotate' | 'route';
+        lowRiskModel: string | undefined;
+        findingThreshold: number;
+        requestChanges: boolean;
+    };
 }
-export type ConfigInput = Partial<Omit<Config, 'provider' | 'sandbox'>> & {
+export type ConfigInput = Partial<Omit<Config, 'provider' | 'sandbox' | 'review'>> & {
     provider?: Partial<ProviderRules>;
     sandbox?: Partial<Sandbox>;
+    review?: Partial<Config['review']>;
 };
 export declare const DEFAULT_RECORD_STEP_CAP = 40;
 export declare const DEFAULT_SANDBOX: Sandbox;
 export declare function defineConfig(input: ConfigInput): ConfigInput;
+/**
+ * Which severities fail the review status. `review.severityGate` is the
+ * consumer-facing alias over `severity` — 'risk' fails on bug|risk,
+ * 'bug' on bugs only; unset → the `severity` list is authoritative.
+ */
+export declare function resolveBlockSeverities(config: Config): string[];
+/**
+ * Inline-comment cap: `ARGUS_MAX_COMMENTS` (the action's `max-comments`
+ * input) wins when it parses as a non-negative integer — it's set by the
+ * workflow author, so an untrusted PR config can't reach it (`review`
+ * isn't on the untrusted allowlist). Anything else → `review.maxComments`.
+ */
+export declare function resolveMaxComments(env: Record<string, string | undefined>, config: Config): number;
 export declare function resolveConfig(input?: ConfigInput): Config;
-export declare function loadConfig(cwd: string): Promise<Config>;
+export interface LoadConfigOpts {
+    /**
+     * Required — there is no default. Every call site must state the
+     * checkout's trust so a missed or future caller can't silently execute
+     * config code on a hostile tree (see src/trust.ts).
+     */
+    trust: Trust;
+    /** Human-readable note on security-relevant load decisions (e.g. ctx.err). */
+    note?: (line: string) => void;
+}
+export declare function loadConfig(cwd: string, opts: LoadConfigOpts): Promise<Config>;
 /**
  * Provider slugs the harness recognizes for `provider.only/ignore/order`
  * (KTD4). Unknown slugs warn but do not fail — OpenRouter's catalog changes

package/dist/config.js

@@ -1,4 +1,5 @@
 import { pathToFileURL } from 'node:url';
+import { JEV_DEFAULT_MODEL } from './vision/decisions.js';
 export const DEFAULT_RECORD_STEP_CAP = 40;
 export const DEFAULT_SANDBOX = {
     enabled: false,
@@ -15,6 +16,7 @@ const defaults = {
     escalation_model: 'moonshotai/kimi-k2.5',
     grounding_model: undefined,
     code_model: 'deepseek/deepseek-v4.1-flash',
+    decisionModel: JEV_DEFAULT_MODEL,
     codeReviewBudgetUsd: undefined,
     provider: {
         ignore: ['siliconflow', 'novitaai', 'atlascloud', 'streamlake', 'chutes'],
@@ -38,6 +40,15 @@ const defaults = {
     a0: undefined,
     heal: 'local',
     sandbox: { ...DEFAULT_SANDBOX },
+    review: {
+        secretsThreshold: 0.3,
+        maxComments: 20,
+        severityGate: undefined,
+        triage: 'annotate',
+        lowRiskModel: undefined,
+        findingThreshold: 1.0,
+        requestChanges: true,
+    },
 };
 export function defineConfig(input) {
     return input;
@@ -46,6 +57,36 @@ export function defineConfig(input) {
 function posInt(v, dflt) {
     return v !== undefined && Number.isFinite(v) && v >= 1 ? Math.floor(v) : dflt;
 }
+/** Probability config values (must be in [0,1]) fall back to their default. */
+function prob01(v, dflt) {
+    return v !== undefined && Number.isFinite(v) && v >= 0 && v <= 1 ? v : dflt;
+}
+/**
+ * Which severities fail the review status. `review.severityGate` is the
+ * consumer-facing alias over `severity` — 'risk' fails on bug|risk,
+ * 'bug' on bugs only; unset → the `severity` list is authoritative.
+ */
+export function resolveBlockSeverities(config) {
+    if (config.review.severityGate === 'risk')
+        return ['bug', 'risk'];
+    if (config.review.severityGate === 'bug')
+        return ['bug'];
+    return config.severity ?? ['bug'];
+}
+/**
+ * Inline-comment cap: `ARGUS_MAX_COMMENTS` (the action's `max-comments`
+ * input) wins when it parses as a non-negative integer — it's set by the
+ * workflow author, so an untrusted PR config can't reach it (`review`
+ * isn't on the untrusted allowlist). Anything else → `review.maxComments`.
+ */
+export function resolveMaxComments(env, config) {
+    const raw = env.ARGUS_MAX_COMMENTS?.trim();
+    // ^\d+$ — Number() would also accept '0x10', '1e2', ' 4 ', 'Infinity'.
+    if (raw !== undefined && /^\d+$/.test(raw)) {
+        return Number(raw);
+    }
+    return config.review.maxComments;
+}
 export function resolveConfig(input = {}) {
     const provider = { ...defaults.provider, ...(input.provider ?? {}) };
     // Wrong-typed sandbox values (e.g. `sandbox: true`, `enabled: 'yes'`,
@@ -56,23 +97,108 @@ export function resolveConfig(input = {}) {
     sandbox.enabled = raw.enabled === true;
     sandbox.allowForks = raw.allowForks === true;
     sandbox.image = typeof raw.image === 'string' && raw.image !== '' ? raw.image : undefined;
-    sandbox.memory = typeof raw.memory === 'string' && raw.memory !== '' ? raw.memory : DEFAULT_SANDBOX.memory;
+    sandbox.memory =
+        typeof raw.memory === 'string' && raw.memory !== '' ? raw.memory : DEFAULT_SANDBOX.memory;
     sandbox.cpus = typeof raw.cpus === 'string' && raw.cpus !== '' ? raw.cpus : DEFAULT_SANDBOX.cpus;
     sandbox.maxProbes = posInt(sandbox.maxProbes, DEFAULT_SANDBOX.maxProbes);
     sandbox.timeoutMs = posInt(sandbox.timeoutMs, DEFAULT_SANDBOX.timeoutMs);
     sandbox.pidsLimit = posInt(sandbox.pidsLimit, DEFAULT_SANDBOX.pidsLimit);
-    const resolved = { ...defaults, ...input, provider, sandbox };
+    const rawReview = typeof input.review === 'object' && input.review !== null ? input.review : {};
+    const review = { ...defaults.review, ...rawReview };
+    // Thresholds must be probabilities — anything else (NaN, >1,
+    // negative) would silently suppress or flood the Jev lanes.
+    review.secretsThreshold = prob01(review.secretsThreshold, defaults.review.secretsThreshold);
+    review.maxComments =
+        typeof review.maxComments === 'number' &&
+            Number.isInteger(review.maxComments) &&
+            review.maxComments >= 0
+            ? review.maxComments
+            : defaults.review.maxComments;
+    if (review.severityGate !== 'bug' && review.severityGate !== 'risk') {
+        review.severityGate = undefined;
+    }
+    if (review.triage !== 'off' && review.triage !== 'annotate' && review.triage !== 'route') {
+        review.triage = defaults.review.triage;
+    }
+    if (typeof review.lowRiskModel !== 'string' || review.lowRiskModel === '') {
+        review.lowRiskModel = undefined;
+    }
+    review.findingThreshold = prob01(review.findingThreshold, defaults.review.findingThreshold);
+    // Advisory-only escape hatch — only literal `false` opts out; anything
+    // else (mis-typed values included) keeps the default-true posture.
+    review.requestChanges = review.requestChanges !== false;
+    const resolved = { ...defaults, ...input, provider, sandbox, review };
     resolved.recordStepCap = posInt(resolved.recordStepCap, DEFAULT_RECORD_STEP_CAP);
     if (resolved.heal !== 'a0')
         resolved.heal = 'local';
+    // '' is the documented opt-out — an empty slug would send a broken
+    // model id to the decisions endpoint on every adjudication call.
+    if (resolved.decisionModel === '')
+        resolved.decisionModel = undefined;
     return resolved;
 }
-export async function loadConfig(cwd) {
+/**
+ * Config keys honored on untrusted checkouts — policy-free fields only.
+ * Everything else (exec-bearing fields, model/budget/provider selection,
+ * severity/verdict policy, credentials maps, network endpoints, write
+ * locations) is ignored: the review policy over hostile code must not be
+ * authored by that code.
+ */
+const UNTRUSTED_CONFIG_KEYS = new Set(['logLevel', 'sourceGlobs']);
+function filterUntrustedConfig(input) {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (UNTRUSTED_CONFIG_KEYS.has(key))
+            out[key] = value;
+    }
+    return out;
+}
+export async function loadConfig(cwd, opts) {
     const fs = await import('node:fs/promises');
     const path = await import('node:path');
+    const untrusted = opts.trust === 'untrusted';
+    // cacheDir is the documented CLI default '.argus-reviewer-cache' — normalize
+    // it to an absolute path here so engine record/replay persistence (gated on
+    // config.cacheDir) writes where every other consumer already falls back to.
+    const finish = async (input = {}) => {
+        const config = resolveConfig(input);
+        const cacheDir = path.resolve(cwd, config.cacheDir ?? '.argus-reviewer-cache');
+        if (untrusted) {
+            // A hostile PR can commit the default path as a symlink and redirect
+            // cache writes outside the checkout — fail closed before writers run.
+            let isSymlink = false;
+            try {
+                isSymlink = (await fs.lstat(cacheDir)).isSymbolicLink();
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+            if (isSymlink) {
+                throw new Error(`untrusted cache directory must not be a symlink: ${cacheDir}`);
+            }
+        }
+        config.cacheDir = cacheDir;
+        return config;
+    };
     const names = ['argus-reviewer.config', 'vision-e2e.config'];
     for (const name of names) {
-        for (const ext of ['.ts', '.json']) {
+        if (untrusted) {
+            // Surface skipped .ts candidates — otherwise a hostile config (or a
+            // legit consumer debugging "why is my config ignored") is invisible.
+            try {
+                if ((await fs.stat(path.join(cwd, `${name}.ts`))).isFile()) {
+                    opts.note?.(`config: ${name}.ts ignored — untrusted checkouts load JSON config only`);
+                }
+            }
+            catch {
+                // no .ts candidate — nothing to note
+            }
+        }
+        // .ts is tried before .json, so an untrusted checkout must skip the .ts
+        // candidate *before* it can shadow a committed .json — importing it
+        // executes arbitrary code beside the runner's secrets (#58).
+        for (const ext of untrusted ? ['.json'] : ['.ts', '.json']) {
             const file = path.join(cwd, `${name}${ext}`);
             try {
                 const stat = await fs.stat(file);
@@ -80,7 +206,12 @@ export async function loadConfig(cwd) {
                     continue;
                 if (ext === '.json') {
                     const raw = await fs.readFile(file, 'utf8');
-                    return resolveConfig(JSON.parse(raw));
+                    const parsed = JSON.parse(raw);
+                    if (untrusted) {
+                        opts.note?.(`config: ${name}.json loaded untrusted — honoring ${[...UNTRUSTED_CONFIG_KEYS].join(', ')} only`);
+                        return finish(filterUntrustedConfig(parsed));
+                    }
+                    return finish(parsed);
                 }
                 // Always transpile .ts to a temp .mjs rather than importing natively:
                 // Node's built-in type stripping resolves the module type from the
@@ -111,7 +242,7 @@ export async function loadConfig(cwd) {
                     await rm(out, { force: true }).catch(() => undefined);
                 }
                 const exported = mod.default ?? mod;
-                return resolveConfig(exported);
+                return finish(exported);
             }
             catch (e) {
                 const code = e.code;
@@ -121,7 +252,7 @@ export async function loadConfig(cwd) {
             }
         }
     }
-    return resolveConfig();
+    return finish();
 }
 /**
  * Provider slugs the harness recognizes for `provider.only/ignore/order`

package/dist/debug.d.ts

@@ -1 +1,2 @@
+export declare function setLiveDir(dir: string | undefined): void;
 export declare function debug(kind: string, ...args: unknown[]): void;

package/dist/debug.js

@@ -1,8 +1,14 @@
 import { join } from 'node:path';
 import { liveLog } from './live.js';
 const DEBUG = process.env.ARGUS_DEBUG === '1' || process.env.ARGUS_DEBUG === 'true';
-// debug() has no config access — it lives under the default cache dir.
-const LIVE_DIR = join(process.cwd(), '.argus-reviewer-cache');
+// debug() has no config access — it defaults to the conventional cache dir,
+// and callers that resolve a config set the real live dir once it's known
+// (otherwise debug lines and stage lines would split across two dirs).
+const DEFAULT_LIVE_DIR = join(process.cwd(), '.argus-reviewer-cache');
+let liveDir = DEFAULT_LIVE_DIR;
+export function setLiveDir(dir) {
+    liveDir = dir ?? DEFAULT_LIVE_DIR;
+}
 function toMsg(arg) {
     if (typeof arg === 'string')
         return arg;
@@ -18,7 +24,7 @@ export function debug(kind, ...args) {
     if (!DEBUG)
         return; // keep debug() free of fs work on the hot path
     for (const arg of args) {
-        liveLog(LIVE_DIR, kind, 'debug', toMsg(arg));
+        liveLog(liveDir, kind, 'debug', toMsg(arg));
         const prefix = `[argus-reviewer:${kind}]`;
         if (typeof arg === 'string') {
             console.error(`${prefix} ${arg}`);

package/dist/engine/loop.d.ts

@@ -62,6 +62,15 @@ export interface RunResult {
     reason?: string;
     steps: StepResult[];
     visionCalls: number;
+    cache: CacheStats;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    heals: number;
+    staleEntries: number;
+    assertionHits: number;
+    assertionMisses: number;
 }
 export interface AssertResult extends AssertionResult {
     cached: boolean;
@@ -81,6 +90,7 @@ export declare class Engine {
     private _fingerprints;
     private _assertCache;
     private _errors;
+    private _cacheStats;
     /** Structured, non-fatal anomalies — journaled as evidence, never thrown. */
     get errorRecords(): ErrorRecord[];
     private _note;
@@ -88,6 +98,7 @@ export declare class Engine {
     /** Assertion verdicts collected/known this run — persist into the flow cache. */
     get assertEntries(): CachedAssert[];
     get visionCalls(): number;
+    get cacheStats(): CacheStats;
     record(instruction: string, tdApi?: TestDriverApi, options?: RecordOptions): Promise<RunResult>;
     replay(flow: FlowCache, options?: ReplayOptions): Promise<RunResult>;
     /**
@@ -114,5 +125,6 @@ export declare class Engine {
     private _buildFingerprint;
     private _regionScreenshot;
     private _result;
+    private _resetCacheStats;
 }
 export declare function instructionMatchesNode(instruction: string, nodeSnippet: string): boolean;

package/dist/engine/loop.js

@@ -9,6 +9,14 @@ export class Engine {
     _fingerprints = [];
     _assertCache = new Map();
     _errors = [];
+    _cacheStats = {
+        hits: 0,
+        misses: 0,
+        heals: 0,
+        staleEntries: 0,
+        assertionHits: 0,
+        assertionMisses: 0,
+    };
     /** Structured, non-fatal anomalies — journaled as evidence, never thrown. */
     get errorRecords() {
         return this._errors;
@@ -31,10 +39,14 @@ export class Engine {
     get visionCalls() {
         return this._visionCalls;
     }
+    get cacheStats() {
+        return { ...this._cacheStats };
+    }
     async record(instruction, tdApi = this._opts.actions, options = {}) {
         this._visionCalls = 0;
         this._steps = [];
         this._fingerprints = [];
+        this._resetCacheStats();
         const cap = options.stepCap ?? this._opts.config.recordStepCap ?? DEFAULT_RECORD_STEP_CAP;
         let observation = await this._opts.driver.observe({ grid: true });
         for (let i = 0; i < cap; i++) {
@@ -82,16 +94,18 @@ export class Engine {
     async replay(flow, options = {}) {
         this._visionCalls = 0;
         this._steps = [];
+        this._resetCacheStats();
         for (let i = 0; i < flow.steps.length; i++) {
             const step = flow.steps[i];
             if (!step)
                 continue;
-            let observation = await this._opts.driver.observe({ grid: true });
+            const observation = await this._opts.driver.observe({ grid: true });
             // Diff-invalidated entries skip hash verification entirely and go
             // straight to the heal path — the diff already told us they're stale.
             let resolve;
             if (step.stale !== undefined) {
                 this._note('heal', 'cache entry invalidated by diff', step.stale);
+                this._cacheStats.staleEntries++;
                 resolve = { matched: false, currentHash: '', regionMatched: false, a11yMatched: false };
             }
             else {
@@ -99,10 +113,12 @@ export class Engine {
                 resolve = new Fingerprint(step).resolve(regionBuffer, observation.a11yYaml);
             }
             if (resolve.matched) {
+                this._cacheStats.hits++;
                 await this._executeAction(this._opts.actions, step.action);
                 this._steps.push({ instruction: step.instruction, action: step.action.action, ok: true });
                 continue;
             }
+            this._cacheStats.misses++;
             if (this._opts.ledger.replayOnly || !this._opts.ledger.canSpend(0.001)) {
                 this._steps.push({
                     instruction: step.instruction,
@@ -144,9 +160,10 @@ export class Engine {
                 return this._result(false);
             }
             const resolved = await this._resolveAction(action);
-            const nextObservation = await this._executeAction(this._opts.actions, action);
+            await this._executeAction(this._opts.actions, action);
             const newFingerprint = await this._buildFingerprint(step.instruction, action, resolved, response.model);
             flow.steps[i] = newFingerprint;
+            this._cacheStats.heals++;
             this._note('heal', 'fingerprint mismatch healed by model', step.instruction);
             this._steps.push({
                 instruction: step.instruction,
@@ -155,7 +172,6 @@ export class Engine {
                 healed: true,
                 model: response.model,
             });
-            observation = nextObservation;
         }
         if (options.flowName && this._opts.config.cacheDir) {
             await saveFlow(this._opts.config.cacheDir, options.flowName, flow.steps);
@@ -177,6 +193,7 @@ export class Engine {
             const regionBuffer = await this._regionScreenshot(cached.bbox);
             const resolve = new Fingerprint(cached).resolve(regionBuffer, observation.a11yYaml);
             if (resolve.matched) {
+                this._cacheStats.hits++;
                 return {
                     ok: true,
                     reason: undefined,
@@ -186,6 +203,7 @@ export class Engine {
                     model: undefined,
                 };
             }
+            this._cacheStats.misses++;
             if (this._opts.ledger.replayOnly || !this._opts.ledger.canSpend(0.001)) {
                 return {
                     ok: false,
@@ -197,6 +215,13 @@ export class Engine {
                 };
             }
         }
+        else if (cached?.stale !== undefined) {
+            this._cacheStats.misses++;
+            this._cacheStats.staleEntries++;
+        }
+        else {
+            this._cacheStats.misses++;
+        }
         // A diff-invalidated (stale) entry is a fresh ground, not a heal — heal
         // implies the fingerprint *checked out as wrong*, stale means we never
         // verified it. Keeping the kind split honest keeps the heal-rate signal
@@ -205,8 +230,11 @@ export class Engine {
         const isStale = cached !== undefined && cached.stale !== undefined;
         const useHeal = cached !== undefined && !isStale;
         const primary = await this._locateWithModel(instruction, observation, useHeal);
-        if (primary.ok)
+        if (primary.ok) {
+            if (useHeal)
+                this._cacheStats.heals++;
             return primary;
+        }
         // Semantic escalation fallback (issue #14): the model answered but could
         // not ground — provider-level OpenRouter fallback only covers unavailable
         // models, not bad answers. Retry once with escalation_model as primary on
@@ -221,7 +249,10 @@ export class Engine {
         }
         this._note('locate', 'escalating to fallback model', `failed=${failedModel} esc=${esc} reason=${(primary.reason ?? '').slice(0, 80)}`);
         const fresh = await this._opts.driver.observe({ grid: true });
-        return this._locateWithModel(instruction, fresh, useHeal, esc);
+        const escalated = await this._locateWithModel(instruction, fresh, useHeal, esc);
+        if (escalated.ok && useHeal)
+            this._cacheStats.heals++;
+        return escalated;
     }
     /**
      * One locate attempt against a specific model: initial call plus the
@@ -388,8 +419,10 @@ export class Engine {
         const key = `${question}${a11yHash}`;
         const cached = this._assertCache.get(key);
         if (cached) {
+            this._cacheStats.assertionHits++;
             return { verdict: cached.verdict, reasoning: cached.reasoning, cached: true };
         }
+        this._cacheStats.assertionMisses++;
         if (this._opts.ledger.replayOnly || !this._opts.ledger.canSpend(0.001)) {
             return { verdict: 'fail', reasoning: 'budget exceeded or replay-only', cached: false };
         }
@@ -621,7 +654,23 @@ export class Engine {
         return Buffer.from(raw);
     }
     _result(ok, reason) {
-        return { ok, steps: this._steps, visionCalls: this._visionCalls, ...(reason ? { reason } : {}) };
+        return {
+            ok,
+            steps: this._steps,
+            visionCalls: this._visionCalls,
+            cache: this.cacheStats,
+            ...(reason ? { reason } : {}),
+        };
+    }
+    _resetCacheStats() {
+        this._cacheStats = {
+            hits: 0,
+            misses: 0,
+            heals: 0,
+            staleEntries: 0,
+            assertionHits: 0,
+            assertionMisses: 0,
+        };
     }
 }
 /**

package/dist/evidence/ci.d.ts

@@ -42,6 +42,9 @@ export interface PrMeta {
      * timeline fetch failed (the gate fails closed either way).
      */
     labelApprovedAt: string | undefined;
+    /** PR title/body — triage state only (untrusted text; feeds Jev, never gates). */
+    title: string | undefined;
+    body: string | undefined;
 }
 /**
  * Shared GitHub GET scaffold — Bearer auth, API headers, 30s abort timeout,

package/dist/evidence/ci.js

@@ -6,7 +6,7 @@ export const PROBE_LABEL = 'argus-probe';
  * FIRST_TIMER, MANNEQUIN, and NONE are not.
  */
 export function isTrustedAssociation(association) {
-    return (association === 'MEMBER' || association === 'OWNER' || association === 'COLLABORATOR');
+    return association === 'MEMBER' || association === 'OWNER' || association === 'COLLABORATOR';
 }
 const GH_API = 'https://api.github.com';
 const MAX_CHECK_RUN_PAGES = 5;
@@ -85,6 +85,8 @@ export async function fetchPrMeta(repo, pr, token, ctx) {
         labels,
         pushedAt: data.head?.repo?.pushed_at,
         labelApprovedAt,
+        title: typeof data.title === 'string' ? data.title : undefined,
+        body: typeof data.body === 'string' ? data.body : undefined,
     };
 }
 /**

package/dist/pipeline/budget.d.ts

@@ -0,0 +1,11 @@
+import type { CallCost } from '../vision/cost.js';
+import type { BudgetSummary, LaneId } from '../report/manifest.js';
+export interface BudgetOptions {
+    limitUsd?: number;
+    maxDurationMs?: number;
+    maxTasks?: number;
+}
+export declare function createBudget(lane: LaneId, options?: BudgetOptions): BudgetSummary;
+export declare function addProviderCalls(budget: BudgetSummary, calls: CallCost[] | undefined): BudgetSummary;
+export declare function addA0Task(budget: BudgetSummary, elapsedMs: number, metered: boolean): BudgetSummary;
+export declare function budgetCanSpend(budget: BudgetSummary, nextCostUsd: number): boolean;

package/dist/pipeline/budget.js

@@ -0,0 +1,48 @@
+export function createBudget(lane, options = {}) {
+    void lane;
+    return {
+        limitUsd: options.limitUsd,
+        spentUsd: 0,
+        exceeded: false,
+        maxDurationMs: options.maxDurationMs,
+        elapsedMs: 0,
+        maxTasks: options.maxTasks,
+        tasks: 0,
+    };
+}
+/**
+ * USD spend is summed as IEEE-754 doubles, so a lane that lands exactly on its
+ * cap (0.1 + 0.2 === 0.30000000000000004, not 0.3) would otherwise read as over
+ * budget and abort a run that never exceeded the cap. Compare with a tolerance
+ * far below the 1e-6 precision reports render, and far above double noise here.
+ */
+const USD_EPSILON = 1e-9;
+function overLimit(spentUsd, limitUsd) {
+    return spentUsd > limitUsd + USD_EPSILON;
+}
+export function addProviderCalls(budget, calls) {
+    if (calls === undefined || calls.length === 0)
+        return budget;
+    const spentUsd = calls.reduce((sum, call) => sum + call.costUsd, 0);
+    const exceeded = budget.exceeded ||
+        (budget.limitUsd !== undefined && overLimit(budget.spentUsd + spentUsd, budget.limitUsd));
+    return {
+        ...budget,
+        spentUsd: budget.spentUsd + spentUsd,
+        exceeded,
+    };
+}
+export function addA0Task(budget, elapsedMs, metered) {
+    const tasks = budget.tasks + 1;
+    const elapsed = budget.elapsedMs + elapsedMs;
+    const exceeded = budget.exceeded ||
+        (budget.maxTasks !== undefined && tasks > budget.maxTasks) ||
+        (budget.maxDurationMs !== undefined && elapsed > budget.maxDurationMs) ||
+        (budget.limitUsd !== undefined && metered && overLimit(budget.spentUsd, budget.limitUsd));
+    return { ...budget, tasks, elapsedMs: elapsed, exceeded };
+}
+export function budgetCanSpend(budget, nextCostUsd) {
+    return (!budget.exceeded &&
+        (budget.limitUsd === undefined ||
+            budget.spentUsd + nextCostUsd <= budget.limitUsd + USD_EPSILON));
+}

package/dist/pipeline/contracts.d.ts

@@ -0,0 +1,12 @@
+import { LANE_IDS, type LaneId } from '../report/manifest.js';
+export { LANE_IDS };
+export type { LaneId };
+export interface LaneSelection {
+    review: boolean;
+    flow: boolean;
+    app: boolean;
+    a0: boolean;
+}
+export declare function defaultLaneSelection(): LaneSelection;
+export declare function selectionFromFlags(flags: Partial<Record<LaneId, boolean>>): LaneSelection;
+export declare function selectedLanes(selection: LaneSelection): LaneId[];

package/dist/pipeline/contracts.js

@@ -0,0 +1,16 @@
+import { LANE_IDS } from '../report/manifest.js';
+export { LANE_IDS };
+export function defaultLaneSelection() {
+    return { review: true, flow: false, app: false, a0: false };
+}
+export function selectionFromFlags(flags) {
+    const selection = defaultLaneSelection();
+    for (const lane of LANE_IDS) {
+        if (flags[lane] !== undefined)
+            selection[lane] = flags[lane];
+    }
+    return selection;
+}
+export function selectedLanes(selection) {
+    return LANE_IDS.filter((lane) => selection[lane]);
+}