argus-reviewer-e2e 0.2.0 → 0.3.1

package/dist/report/manifest.d.ts

@@ -0,0 +1,87 @@
+import { type ExecFn } from '../detect.js';
+import type { CallCost } from '../vision/cost.js';
+/** Whether a report's source can be tied to the intended PR head. */
+export type HeadBindingStatus = 'match' | 'mismatch' | 'unknown' | 'not_applicable';
+export type HeadSource = 'github' | 'fixture' | 'local';
+export declare const LANE_IDS: readonly ["review", "flow", "app", "a0"];
+export type LaneId = (typeof LANE_IDS)[number];
+export declare const LANE_STATUSES: readonly ["passed", "failed", "skipped", "blocked", "unavailable", "inconclusive"];
+export type LaneStatus = (typeof LANE_STATUSES)[number];
+export declare const MANIFEST_SCHEMA_VERSION: 1;
+export interface HeadBinding {
+    intendedSha: string | undefined;
+    checkoutSha: string | undefined;
+    status: HeadBindingStatus;
+    source: HeadSource;
+    detail: string;
+}
+export interface UsageSummary {
+    provider: 'openrouter' | 'a0' | 'unknown';
+    model: string | undefined;
+    calls: number;
+    tokens: number;
+    costUsd: number;
+    metered: boolean;
+}
+export interface BudgetSummary {
+    limitUsd: number | undefined;
+    spentUsd: number;
+    exceeded: boolean;
+    maxDurationMs: number | undefined;
+    elapsedMs: number;
+    maxTasks: number | undefined;
+    tasks: number;
+}
+export interface LaneManifest {
+    lane: LaneId;
+    selected: boolean;
+    status: LaneStatus;
+    startedAt: string | undefined;
+    finishedAt: string | undefined;
+    reportPath: string | undefined;
+    model: string | undefined;
+    summary: string | undefined;
+    reason: string | undefined;
+    usage: UsageSummary;
+    budget: BudgetSummary;
+    headBinding: HeadBinding | undefined;
+}
+export interface RunIdentity {
+    repo: string | undefined;
+    pr: string | undefined;
+    intendedHeadSha: string | undefined;
+    checkoutSha: string | undefined;
+    baseSha: string | undefined;
+}
+export interface RunManifest {
+    schemaVersion: typeof MANIFEST_SCHEMA_VERSION;
+    runId: string;
+    startedAt: string;
+    finishedAt: string;
+    identity: RunIdentity;
+    lanes: Record<LaneId, LaneManifest>;
+    aggregate: {
+        status: LaneStatus;
+        ok: boolean;
+        costUsd: number;
+        calls: number;
+        tokens: number;
+    };
+}
+/** Read the checked-out commit without making git identity a hard dependency. */
+export declare function readCheckoutSha(cwd: string, exec?: ExecFn): Promise<string | undefined>;
+/** Classify the relationship between API/fixture head identity and the checkout. */
+export declare function classifyHeadBinding(intendedSha: string | undefined, checkoutSha: string | undefined, source: HeadSource): HeadBinding;
+/** True when runtime evidence is bound to the intended head (or a fixture). */
+export declare function isHeadBindingConclusive(binding: HeadBinding | undefined): boolean;
+export declare function emptyUsage(provider?: UsageSummary['provider']): UsageSummary;
+export declare function emptyBudget(): BudgetSummary;
+export declare function emptyLane(lane: LaneId, selected: boolean): LaneManifest;
+export declare function aggregateLanes(lanes: Record<LaneId, LaneManifest>): {
+    status: LaneStatus;
+    ok: boolean;
+    costUsd: number;
+    calls: number;
+    tokens: number;
+};
+export declare function addProviderUsage(usage: UsageSummary, calls: CallCost[] | undefined): UsageSummary;

package/dist/report/manifest.js

@@ -0,0 +1,143 @@
+import { defaultExec } from '../detect.js';
+export const LANE_IDS = ['review', 'flow', 'app', 'a0'];
+export const LANE_STATUSES = [
+    'passed',
+    'failed',
+    'skipped',
+    'blocked',
+    'unavailable',
+    'inconclusive',
+];
+export const MANIFEST_SCHEMA_VERSION = 1;
+/** Read the checked-out commit without making git identity a hard dependency. */
+export async function readCheckoutSha(cwd, exec = defaultExec) {
+    const result = await exec('git', ['-C', cwd, 'rev-parse', 'HEAD'], 10_000);
+    if (result.code !== 0)
+        return undefined;
+    const sha = result.stdout.trim();
+    return sha === '' ? undefined : sha;
+}
+/** Classify the relationship between API/fixture head identity and the checkout. */
+export function classifyHeadBinding(intendedSha, checkoutSha, source) {
+    if (source === 'fixture') {
+        return {
+            intendedSha,
+            checkoutSha,
+            status: 'not_applicable',
+            source,
+            detail: 'fixture diff is bound to its local fixture head',
+        };
+    }
+    if (intendedSha === undefined || intendedSha === '') {
+        return {
+            intendedSha,
+            checkoutSha,
+            status: 'unknown',
+            source,
+            detail: 'PR head identity was unavailable',
+        };
+    }
+    if (checkoutSha === undefined || checkoutSha === '') {
+        return {
+            intendedSha,
+            checkoutSha,
+            status: 'unknown',
+            source,
+            detail: 'checkout identity was unavailable',
+        };
+    }
+    if (intendedSha === checkoutSha) {
+        return {
+            intendedSha,
+            checkoutSha,
+            status: 'match',
+            source,
+            detail: 'checkout matches the intended PR head',
+        };
+    }
+    return {
+        intendedSha,
+        checkoutSha,
+        status: 'mismatch',
+        source,
+        detail: `checkout ${checkoutSha} does not match intended PR head ${intendedSha}`,
+    };
+}
+/** True when runtime evidence is bound to the intended head (or a fixture). */
+export function isHeadBindingConclusive(binding) {
+    return binding?.status === 'match' || binding?.status === 'not_applicable';
+}
+export function emptyUsage(provider = 'unknown') {
+    return {
+        provider,
+        model: undefined,
+        calls: 0,
+        tokens: 0,
+        costUsd: 0,
+        metered: provider !== 'a0',
+    };
+}
+export function emptyBudget() {
+    return {
+        limitUsd: undefined,
+        spentUsd: 0,
+        exceeded: false,
+        maxDurationMs: undefined,
+        elapsedMs: 0,
+        maxTasks: undefined,
+        tasks: 0,
+    };
+}
+export function emptyLane(lane, selected) {
+    return {
+        lane,
+        selected,
+        status: selected ? 'blocked' : 'skipped',
+        startedAt: undefined,
+        finishedAt: undefined,
+        reportPath: undefined,
+        model: undefined,
+        summary: undefined,
+        reason: undefined,
+        usage: emptyUsage(),
+        budget: emptyBudget(),
+        headBinding: undefined,
+    };
+}
+export function aggregateLanes(lanes) {
+    const selected = LANE_IDS.map((lane) => lanes[lane]).filter((lane) => lane.selected);
+    const hasFailure = selected.some((lane) => ['failed', 'blocked'].includes(lane.status));
+    const hasInconclusive = selected.some((lane) => lane.status === 'inconclusive');
+    const hasUnavailable = selected.some((lane) => lane.status === 'unavailable');
+    const status = hasFailure
+        ? 'failed'
+        : hasInconclusive || hasUnavailable
+            ? 'inconclusive'
+            : selected.length === 0 || selected.every((lane) => lane.status === 'skipped')
+                ? 'skipped'
+                : selected.every((lane) => lane.status === 'passed' || lane.status === 'skipped')
+                    ? 'passed'
+                    : 'inconclusive';
+    return {
+        status,
+        ok: status === 'passed',
+        costUsd: selected.reduce((sum, lane) => sum + lane.usage.costUsd, 0),
+        calls: selected.reduce((sum, lane) => sum + lane.usage.calls, 0),
+        tokens: selected.reduce((sum, lane) => sum + lane.usage.tokens, 0),
+    };
+}
+export function addProviderUsage(usage, calls) {
+    if (calls === undefined || calls.length === 0)
+        return usage;
+    const costUsd = calls.reduce((sum, call) => sum + call.costUsd, 0);
+    const tokens = calls.reduce((sum, call) => sum + call.tokens, 0);
+    const model = calls.at(-1)?.model;
+    return {
+        provider: 'openrouter',
+        model: usage.model ?? model,
+        calls: usage.calls + calls.length,
+        tokens: usage.tokens + tokens,
+        costUsd: usage.costUsd + costUsd,
+        metered: true,
+    };
+}

package/dist/report/run.d.ts

@@ -1,4 +1,5 @@
 import type { HealEvent, TdAssertRecord, TdStepRecord } from '../api.js';
+import type { CacheStats } from '../engine/loop.js';
 import type { CallCost } from '../vision/cost.js';
 /**
  * JSON run report consumed by the GitHub Action (R10): per-test verdicts,
@@ -20,6 +21,8 @@ export interface TestReport {
     /** Per-call cost rows for model-level attribution. */
     calls: CallCost[];
     videoPath: string | undefined;
+    /** Fingerprint replay/grounding counters for this test. */
+    cache?: CacheStats;
     /** Agent Zero's autonomous second opinion on a failure (heal: 'a0'). */
     a0Diagnosis?: string;
 }
@@ -35,6 +38,12 @@ export interface RunTotals {
     costByModel: Record<string, number>;
     /** OpenRouter call count grouped by model id. */
     callsByModel: Record<string, number>;
+    cacheHits: number;
+    cacheMisses: number;
+    cacheHeals: number;
+    staleEntries: number;
+    assertionHits: number;
+    assertionMisses: number;
 }
 export interface RunReport {
     tool: 'argus-reviewer';

package/dist/report/run.js

@@ -24,6 +24,12 @@ export function buildRunReport(tests, startedAt, durationMs) {
             budgetExceeded: tests.some((t) => t.budgetExceeded),
             callsByModel,
             costByModel,
+            cacheHits: tests.reduce((sum, t) => sum + (t.cache?.hits ?? 0), 0),
+            cacheMisses: tests.reduce((sum, t) => sum + (t.cache?.misses ?? 0), 0),
+            cacheHeals: tests.reduce((sum, t) => sum + (t.cache?.heals ?? 0), 0),
+            staleEntries: tests.reduce((sum, t) => sum + (t.cache?.staleEntries ?? 0), 0),
+            assertionHits: tests.reduce((sum, t) => sum + (t.cache?.assertionHits ?? 0), 0),
+            assertionMisses: tests.reduce((sum, t) => sum + (t.cache?.assertionMisses ?? 0), 0),
         },
         tests,
         artifacts: {

package/dist/review/secrets.d.ts

@@ -42,6 +42,8 @@ export interface SecretsScanResult {
         severity: string;
         category?: string;
         message: string;
+        /** Jev P(live) carried through adjudication — feeds the review gate. */
+        p?: number;
     }[];
     /** Audit records for report.secretsScan — literals never included. */
     records: SecretScanRecord[];

package/dist/review/secrets.js

@@ -194,6 +194,10 @@ export async function scanSecrets(opts) {
             severity: adjudicated ? 'bug' : 'risk',
             category: 'security',
             message: maskFindingMessage(c, adjudicated),
+            // A Jev-confirmed live secret counts as proven for the review-event
+            // gate — pLive IS the true-positive probability for this finding.
+            // Unadjudicated findings carry no p (degrade-open, like U8).
+            ...(adjudicated && pLive !== undefined ? { p: pLive } : {}),
         });
         records.push({
             file: c.file,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "argus-reviewer-e2e",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "argus-reviewer — open-source vision-model E2E testing harness. Record, replay, heal, and assert with any OpenRouter model under a hard budget cap.",
   "type": "module",
   "license": "MIT",
@@ -46,18 +46,18 @@
     "demo": "node scripts/demo.mjs"
   },
   "devDependencies": {
-    "@eslint/js": "^9.0.0",
-    "@types/node": "^20.0.0",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^26.6.2",
     "electron": "^44.2.0",
-    "eslint": "^9.0.0",
-    "globals": "^15.0.0",
+    "eslint": "^10.11.0",
+    "globals": "^17.12.0",
     "prettier": "^3.0.0",
     "typescript-eslint": "^8.0.0",
-    "vitest": "^2.0.0"
+    "vitest": "^5.0.1"
   },
   "dependencies": {
     "playwright": "1.63.0",
-    "typescript": "^5.5.0"
+    "typescript": "^6.0.3"
   },
   "repository": {
     "type": "git",