argus-reviewer-e2e 0.3.0 → 0.4.0

package/dist/ui/errors.d.ts

@@ -0,0 +1,54 @@
+import type { Styler } from './style.js';
+/**
+ * CLI error grammar (R14, R15). Every error renders as three lines: the
+ * failed glyph with a one-line summary, the cause, and the next action on a
+ * line of its own so it can be copied. `--json` prints the same facts as one
+ * JSON object with a stable `code`.
+ *
+ * The codes are a closed set and part of the public CLI contract
+ * (docs/quickstart.md). Numeric exit codes are separate and unchanged: the
+ * call site that reports an error still decides the exit code.
+ */
+export declare const ERROR_CODES: readonly ["OPENROUTER_KEY_MISSING", "OPENROUTER_KEY_REJECTED", "OPENROUTER_OUT_OF_CREDIT", "OPENROUTER_RATE_LIMITED", "PROVIDER_UNAVAILABLE", "CONFIG_INVALID", "MANIFEST_UNREADABLE", "A0_UNREACHABLE", "USAGE", "COMMAND_FAILED", "INTERNAL"];
+export type ErrorCode = (typeof ERROR_CODES)[number];
+export declare const ISSUE_URL = "https://github.com/duketopceo/Argus/issues/new";
+export interface CliErrorOptions {
+    fix?: string;
+    retryAfterSeconds?: number;
+    httpStatus?: number;
+    cause?: unknown;
+}
+export declare class CliError extends Error {
+    readonly code: ErrorCode;
+    readonly fix: string | undefined;
+    readonly retryAfterSeconds: number | undefined;
+    /** Diagnostics only: never printed in the human three-line form (R5). */
+    readonly httpStatus: number | undefined;
+    constructor(code: ErrorCode, message: string, opts?: CliErrorOptions);
+}
+/** Seconds until the provider's rate limit resets, from the response headers. */
+export declare function retryAfterSeconds(headers: Headers | undefined, now?: number): number | undefined;
+/**
+ * Map a failed provider response to its class. Statuses that are not a
+ * provider or account condition (400, 404, 422) stay unclassified: they
+ * are request bugs and surface through the caller's own handling.
+ */
+export declare function classifyHttpStatus(status: number, headers?: Headers, now?: number, provider?: string): CliError | undefined;
+/** The most actionable classified error, or undefined unless every error is classified. */
+export declare function pickProviderError(errors: readonly unknown[]): CliError | undefined;
+/** Normalize anything thrown into a CliError; unknown errors become `fallback`. */
+export declare function toCliError(e: unknown, fallback: ErrorCode): CliError;
+export interface RenderOptions {
+    /** Command name for the summary line ("run", "code-review"). */
+    context?: string | undefined;
+    /** The command to re-run, substituted for `{cmd}` in a fix. */
+    rerun?: string | undefined;
+    /** Include the stack (INTERNAL) and diagnostics. */
+    debug?: boolean | undefined;
+    /** Terminal width: the cause line wraps to it (default 80). */
+    width?: number | undefined;
+}
+/** The human form: glyph + summary, cause, fix on its own line. */
+export declare function renderError(err: CliError, style: Styler, opts?: RenderOptions): string[];
+/** The `--json` form: one line, one object, stable `code`. */
+export declare function errorJson(err: CliError, opts?: RenderOptions): string;

package/dist/ui/errors.js

@@ -0,0 +1,236 @@
+import { maskSecrets, STATUS_GLYPH } from '../report/viewmodel.js';
+/**
+ * CLI error grammar (R14, R15). Every error renders as three lines: the
+ * failed glyph with a one-line summary, the cause, and the next action on a
+ * line of its own so it can be copied. `--json` prints the same facts as one
+ * JSON object with a stable `code`.
+ *
+ * The codes are a closed set and part of the public CLI contract
+ * (docs/quickstart.md). Numeric exit codes are separate and unchanged: the
+ * call site that reports an error still decides the exit code.
+ */
+export const ERROR_CODES = [
+    'OPENROUTER_KEY_MISSING',
+    'OPENROUTER_KEY_REJECTED',
+    'OPENROUTER_OUT_OF_CREDIT',
+    'OPENROUTER_RATE_LIMITED',
+    'PROVIDER_UNAVAILABLE',
+    'CONFIG_INVALID',
+    'MANIFEST_UNREADABLE',
+    'A0_UNREACHABLE',
+    'USAGE',
+    'COMMAND_FAILED',
+    'INTERNAL',
+];
+export const ISSUE_URL = 'https://github.com/duketopceo/Argus/issues/new';
+/** One-line summary per code. USAGE uses the error message itself. */
+const TITLE = {
+    OPENROUTER_KEY_MISSING: 'OpenRouter key missing',
+    OPENROUTER_KEY_REJECTED: 'OpenRouter rejected the key',
+    OPENROUTER_OUT_OF_CREDIT: 'OpenRouter key is out of credit',
+    OPENROUTER_RATE_LIMITED: 'OpenRouter rate limit reached',
+    PROVIDER_UNAVAILABLE: 'model provider unavailable',
+    CONFIG_INVALID: 'config could not be loaded',
+    MANIFEST_UNREADABLE: 'run manifest unreadable',
+    A0_UNREACHABLE: 'Agent Zero unreachable',
+    USAGE: 'usage error',
+    COMMAND_FAILED: 'failed',
+    INTERNAL: 'unexpected error (an Argus bug)',
+};
+const KEY_FIX = 'export OPENROUTER_API_KEY=sk-or-...';
+/** Next action per code when the thrower does not supply one. `{cmd}` is the re-run command. */
+const DEFAULT_FIX = {
+    OPENROUTER_KEY_MISSING: KEY_FIX,
+    OPENROUTER_KEY_REJECTED: KEY_FIX,
+    OPENROUTER_OUT_OF_CREDIT: 'https://openrouter.ai/settings/credits',
+    OPENROUTER_RATE_LIMITED: '{cmd}',
+    PROVIDER_UNAVAILABLE: '{cmd}',
+    CONFIG_INVALID: 'edit the config file named above; docs/quickstart.md lists every key',
+    MANIFEST_UNREADABLE: 'argus-reviewer verify',
+    A0_UNREACHABLE: 'argus-reviewer init',
+    USAGE: 'argus-reviewer --help',
+    COMMAND_FAILED: '{cmd} --debug',
+    INTERNAL: ISSUE_URL,
+};
+export class CliError extends Error {
+    code;
+    fix;
+    retryAfterSeconds;
+    /** Diagnostics only: never printed in the human three-line form (R5). */
+    httpStatus;
+    constructor(code, message, opts = {}) {
+        super(message, opts.cause !== undefined ? { cause: opts.cause } : undefined);
+        this.name = 'CliError';
+        this.code = code;
+        this.fix = opts.fix;
+        this.retryAfterSeconds = opts.retryAfterSeconds;
+        this.httpStatus = opts.httpStatus;
+    }
+}
+/** Seconds until the provider's rate limit resets, from the response headers. */
+export function retryAfterSeconds(headers, now = Date.now()) {
+    if (headers === undefined)
+        return undefined;
+    const ra = headers.get('retry-after');
+    if (ra !== null && ra.trim() !== '') {
+        const secs = Number(ra);
+        if (Number.isFinite(secs) && secs >= 0)
+            return Math.ceil(secs);
+        const at = Date.parse(ra);
+        if (Number.isFinite(at))
+            return Math.max(0, Math.ceil((at - now) / 1000));
+    }
+    // OpenRouter's own header: epoch milliseconds of the reset.
+    const reset = headers.get('x-ratelimit-reset');
+    if (reset !== null && reset.trim() !== '') {
+        const at = Number(reset);
+        if (Number.isFinite(at) && at > 0)
+            return Math.max(0, Math.ceil((at - now) / 1000));
+    }
+    return undefined;
+}
+/**
+ * Map a failed provider response to its class. Statuses that are not a
+ * provider or account condition (400, 404, 422) stay unclassified: they
+ * are request bugs and surface through the caller's own handling.
+ */
+export function classifyHttpStatus(status, headers, now = Date.now(), provider = 'OpenRouter') {
+    if (status === 401 || status === 403) {
+        return new CliError('OPENROUTER_KEY_REJECTED', `${provider} did not accept OPENROUTER_API_KEY`, {
+            httpStatus: status,
+        });
+    }
+    if (status === 402) {
+        return new CliError('OPENROUTER_OUT_OF_CREDIT', `${provider} reports no credit left on this key`, {
+            httpStatus: status,
+        });
+    }
+    if (status === 429) {
+        const secs = retryAfterSeconds(headers, now);
+        const when = secs !== undefined ? `resets in ${secs}s` : 'reset time not given; wait a minute';
+        return new CliError('OPENROUTER_RATE_LIMITED', `${provider} is rate limiting this key; ${when}`, {
+            httpStatus: status,
+            ...(secs !== undefined ? { retryAfterSeconds: secs } : {}),
+        });
+    }
+    if (status >= 500 && status <= 599) {
+        return new CliError('PROVIDER_UNAVAILABLE', `${provider} or its upstream provider is down; see status.openrouter.ai`, {
+            httpStatus: status,
+        });
+    }
+    return undefined;
+}
+/** Order for collapsing several candidate failures into one: account problems first. */
+const PROVIDER_PRIORITY = [
+    'OPENROUTER_KEY_REJECTED',
+    'OPENROUTER_OUT_OF_CREDIT',
+    'OPENROUTER_RATE_LIMITED',
+    'PROVIDER_UNAVAILABLE',
+];
+/** The most actionable classified error, or undefined unless every error is classified. */
+export function pickProviderError(errors) {
+    if (errors.length === 0 || !errors.every((e) => e instanceof CliError))
+        return undefined;
+    const classified = errors;
+    for (const code of PROVIDER_PRIORITY) {
+        const hit = classified.find((e) => e.code === code);
+        if (hit !== undefined)
+            return hit;
+    }
+    return classified[0];
+}
+/** Node's parseArgs rejections: usage errors, not bugs. */
+function isParseArgsError(e) {
+    const code = e?.code;
+    return typeof code === 'string' && code.startsWith('ERR_PARSE_ARGS_');
+}
+/** Normalize anything thrown into a CliError; unknown errors become `fallback`. */
+export function toCliError(e, fallback) {
+    if (e instanceof CliError)
+        return e;
+    const code = e?.code;
+    if (typeof code === 'string' && ERROR_CODES.includes(code)) {
+        // A typed error from another layer (DecisionError) that carries a code.
+        const err = e;
+        return new CliError(code, err.message, {
+            cause: e,
+            ...(err.retryAfterSeconds !== undefined ? { retryAfterSeconds: err.retryAfterSeconds } : {}),
+            ...(err.httpStatus !== undefined ? { httpStatus: err.httpStatus } : {}),
+        });
+    }
+    if (isParseArgsError(e))
+        return new CliError('USAGE', e.message, { cause: e });
+    const message = e instanceof Error ? e.message : String(e);
+    return new CliError(fallback, message, { cause: e });
+}
+/** Word-wrap `text` to `width` columns, each line prefixed with `indent`. */
+function wrap(text, width, indent) {
+    const room = Math.max(20, width - indent.length);
+    const lines = [];
+    let line = '';
+    for (const word of text.split(/\s+/).filter((w) => w !== '')) {
+        if (line !== '' && line.length + 1 + word.length > room) {
+            lines.push(indent + line);
+            line = word;
+        }
+        else {
+            line = line === '' ? word : `${line} ${word}`;
+        }
+    }
+    if (line !== '')
+        lines.push(indent + line);
+    return lines;
+}
+function facts(err, opts) {
+    const cause = maskSecrets(err.message);
+    const rerun = opts.rerun ?? 'argus-reviewer';
+    let fix = (err.fix ?? DEFAULT_FIX[err.code]).replaceAll('{cmd}', rerun);
+    if (err.code === 'OPENROUTER_RATE_LIMITED' && err.fix === undefined && err.retryAfterSeconds !== undefined) {
+        fix = `sleep ${err.retryAfterSeconds} && ${rerun}`;
+    }
+    if (err.code === 'USAGE') {
+        const help = opts.context !== undefined ? `argus-reviewer ${opts.context} --help` : 'argus-reviewer --help';
+        return { code: err.code, summary: cause, cause: undefined, fix: err.fix ?? help };
+    }
+    const title = err.code === 'COMMAND_FAILED' ? `${opts.context ?? 'command'} failed` : TITLE[err.code];
+    const summary = opts.context !== undefined && err.code !== 'COMMAND_FAILED' ? `${opts.context}: ${title}` : title;
+    return { code: err.code, summary, cause, fix };
+}
+/** The human form: glyph + summary, cause, fix on its own line. */
+export function renderError(err, style, opts = {}) {
+    const f = facts(err, opts);
+    const lines = [`${style.status('failed', STATUS_GLYPH.failed)} ${style.bold(f.summary)}`];
+    if (f.cause !== undefined && f.cause !== '')
+        lines.push(...wrap(f.cause, opts.width ?? 80, '  '));
+    lines.push(`  ${style.role('accent', f.fix)}`);
+    if (opts.debug === true) {
+        if (err.httpStatus !== undefined)
+            lines.push(style.dim(`  diagnostics: code ${err.code}, http ${err.httpStatus}`));
+        const stack = (err.cause instanceof Error ? err.cause : err).stack;
+        if (stack !== undefined)
+            lines.push(style.dim(maskSecrets(stack)));
+    }
+    return lines;
+}
+/** The `--json` form: one line, one object, stable `code`. */
+export function errorJson(err, opts = {}) {
+    const f = facts(err, opts);
+    const error = {
+        code: f.code,
+        summary: f.summary,
+        ...(f.cause !== undefined ? { cause: f.cause } : {}),
+        fix: f.fix,
+    };
+    if (err.retryAfterSeconds !== undefined)
+        error.retryAfterSeconds = err.retryAfterSeconds;
+    if (err.httpStatus !== undefined)
+        error.httpStatus = err.httpStatus;
+    if (err.code === 'INTERNAL')
+        error.issue = ISSUE_URL;
+    if (opts.debug === true) {
+        const stack = (err.cause instanceof Error ? err.cause : err).stack;
+        if (stack !== undefined)
+            error.stack = maskSecrets(stack);
+    }
+    return JSON.stringify({ error });
+}

package/dist/ui/style.d.ts

@@ -0,0 +1,34 @@
+import type { LaneStatus } from '../report/manifest.js';
+/**
+ * TTY-aware terminal styler (plan KTD5, DESIGN.md 7.7). No dependency: SGR
+ * codes come from the ANSI-16 map that scripts/build-tokens.mjs writes to
+ * assets/brand/ansi.json. That file is not shipped in the npm package, so
+ * the codes are copied here and a unit test pins them to it.
+ */
+export type Role = 'ink' | 'ink-2' | 'ink-3' | 'accent' | 'passed' | 'failed' | 'caution';
+export declare const ROLE_SGR: Record<Role, string>;
+export declare const STATUS_SGR: Record<LaneStatus, string>;
+export interface ColorInputs {
+    env: Record<string, string | undefined>;
+    isTTY: boolean;
+    noColorFlag?: boolean;
+}
+/**
+ * Precedence: `--no-color` and `NO_COLOR` beat `FORCE_COLOR`, which beats
+ * TTY detection. GitHub Actions logs are not a TTY, so they get color only
+ * through `FORCE_COLOR`. An empty `NO_COLOR` does not count (no-color.org),
+ * and `FORCE_COLOR=0`/`false` forces nothing.
+ */
+export declare function colorEnabled({ env, isTTY, noColorFlag }: ColorInputs): boolean;
+export interface Styler {
+    readonly enabled: boolean;
+    role: (role: Role, text: string) => string;
+    status: (status: LaneStatus, text: string) => string;
+    /** The status glyph, colored by status. */
+    glyph: (status: LaneStatus) => string;
+    bold: (text: string) => string;
+    dim: (text: string) => string;
+}
+export declare function createStyler(enabled: boolean): Styler;
+/** The styler for anything that must stay plain (files, JSON, tests). */
+export declare const PLAIN: Styler;

package/dist/ui/style.js

@@ -0,0 +1,48 @@
+import { STATUS_GLYPH } from '../report/viewmodel.js';
+export const ROLE_SGR = {
+    ink: '39',
+    'ink-2': '39',
+    'ink-3': '2',
+    accent: '34',
+    passed: '32',
+    failed: '31',
+    caution: '33',
+};
+export const STATUS_SGR = {
+    passed: '32',
+    failed: '31',
+    inconclusive: '33',
+    blocked: '1',
+    unavailable: '2',
+    skipped: '2',
+};
+/**
+ * Precedence: `--no-color` and `NO_COLOR` beat `FORCE_COLOR`, which beats
+ * TTY detection. GitHub Actions logs are not a TTY, so they get color only
+ * through `FORCE_COLOR`. An empty `NO_COLOR` does not count (no-color.org),
+ * and `FORCE_COLOR=0`/`false` forces nothing.
+ */
+export function colorEnabled({ env, isTTY, noColorFlag }) {
+    if (noColorFlag === true)
+        return false;
+    if (env.NO_COLOR !== undefined && env.NO_COLOR !== '')
+        return false;
+    const force = env.FORCE_COLOR;
+    if (force !== undefined && force !== '' && force !== '0' && force !== 'false')
+        return true;
+    return isTTY;
+}
+export function createStyler(enabled) {
+    // '39' is the terminal default: wrapping it would only add noise.
+    const sgr = (code, text) => !enabled || code === '39' || text === '' ? text : `\x1b[${code}m${text}\x1b[0m`;
+    return {
+        enabled,
+        role: (role, text) => sgr(ROLE_SGR[role], text),
+        status: (status, text) => sgr(STATUS_SGR[status], text),
+        glyph: (status) => sgr(STATUS_SGR[status], STATUS_GLYPH[status]),
+        bold: (text) => sgr('1', text),
+        dim: (text) => sgr('2', text),
+    };
+}
+/** The styler for anything that must stay plain (files, JSON, tests). */
+export const PLAIN = createStyler(false);

package/dist/ui/summary.d.ts

@@ -0,0 +1,38 @@
+import { type LaneStatus, type RunManifest } from '../report/manifest.js';
+import type { Styler } from './style.js';
+/**
+ * End-of-run summary block for `run` and `verify` (R13, DESIGN.md 7.7), in
+ * the same grammar as the PR comment: verdict line, one row per lane, then
+ * total spend against budget and the report path.
+ *
+ *   ⊘ failed   head abc1234   38.1s
+ *     ⊘ review   3 findings, 2 reproduced      $0.003100
+ *     ● flow     4/4 journeys, 1 healed        $0.000000
+ *     total $0.004210 of $1.00 budget · report argus-reviewer-report/run-manifest.json
+ */
+export interface SummaryLane {
+    lane: string;
+    status: LaneStatus;
+    detail: string;
+    costUsd: number;
+    /** false for lanes whose spend Argus cannot see (a0): shows "unmetered". */
+    metered: boolean;
+    limitUsd?: number | undefined;
+    spentUsd?: number | undefined;
+    exceeded?: boolean | undefined;
+}
+export interface SummaryInput {
+    status: LaneStatus;
+    headSha?: string | undefined;
+    durationMs?: number | undefined;
+    lanes: SummaryLane[];
+    totalUsd: number;
+    /** Sum of the lane caps; omitted when no lane has a dollar cap. */
+    budgetUsd?: number | undefined;
+    reportPath?: string | undefined;
+}
+/** The config key that raises each lane's dollar cap (ARGUS_BUDGET_USD overrides all). */
+export declare const BUDGET_KEY: Record<string, string>;
+export declare function renderSummary(input: SummaryInput, style: Styler, width?: number): string[];
+/** Project a verify manifest onto the summary block. */
+export declare function verifySummary(manifest: RunManifest, reportPath: string): SummaryInput;

package/dist/ui/summary.js

@@ -0,0 +1,101 @@
+import { LANE_IDS } from '../report/manifest.js';
+import { formatDuration, formatUsd, LANE_STATUS_LABEL, maskSecrets, shortSha } from '../report/viewmodel.js';
+/** The config key that raises each lane's dollar cap (ARGUS_BUDGET_USD overrides all). */
+export const BUDGET_KEY = {
+    review: 'codeReviewBudgetUsd',
+    flow: 'budgetUsd',
+    app: 'app.budgetUsd',
+};
+const LANE_COL = 7;
+const COST_COL = 9;
+/**
+ * A lane row is 2 indent + glyph + space + lane + 2, the detail, then 2 +
+ * cost: 24 columns plus the detail. Six more columns of slack keep it clear
+ * of the right edge.
+ */
+const FIXED_COLS = 2 + 1 + 1 + LANE_COL + 2 + 2 + COST_COL + 6;
+const DETAIL_MAX = 50;
+const DETAIL_MIN = 16;
+function fit(text, width) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length <= width ? flat.padEnd(width) : `${flat.slice(0, width - 1)}…`;
+}
+const dollars = (n) => `$${n.toFixed(2)}`;
+export function renderSummary(input, style, width = 80) {
+    const head = [
+        `${style.glyph(input.status)} ${style.bold(LANE_STATUS_LABEL[input.status])}`,
+        ...(input.headSha !== undefined ? [`head ${input.headSha}`] : []),
+        ...(input.durationMs !== undefined ? [formatDuration(input.durationMs)] : []),
+    ].join('   ');
+    const lines = [head];
+    const detailWidth = Math.max(DETAIL_MIN, Math.min(DETAIL_MAX, width - FIXED_COLS));
+    for (const lane of input.lanes) {
+        const cost = lane.metered ? formatUsd(lane.costUsd) : 'unmetered';
+        lines.push(`  ${style.glyph(lane.status)} ${lane.lane.padEnd(LANE_COL)}  ` +
+            `${fit(maskSecrets(lane.detail), detailWidth)}  ${style.dim(cost.padStart(COST_COL))}`);
+    }
+    for (const lane of input.lanes) {
+        if (lane.exceeded !== true || lane.limitUsd === undefined)
+            continue;
+        lines.push(`  ${style.glyph('failed')} budget exceeded: spent ${dollars(lane.spentUsd ?? lane.costUsd)} ` +
+            `of ${dollars(lane.limitUsd)} (${lane.lane})`);
+        const key = BUDGET_KEY[lane.lane];
+        if (key !== undefined) {
+            lines.push(`    raise ${key} in the config, or set ARGUS_BUDGET_USD`);
+        }
+    }
+    const total = `total ${formatUsd(input.totalUsd)}` +
+        (input.budgetUsd !== undefined ? ` of ${dollars(input.budgetUsd)} budget` : '');
+    if (input.reportPath === undefined) {
+        lines.push(`  ${total}`);
+    }
+    else {
+        const oneLine = `  ${total} · report ${input.reportPath}`;
+        // Too wide for one line: the report path gets its own, easy to copy.
+        if (oneLine.length <= width)
+            lines.push(oneLine);
+        else
+            lines.push(`  ${total}`, `  report ${input.reportPath}`);
+    }
+    return lines;
+}
+function laneDetail(status, summary, reason) {
+    // A lane that did not pass leads with why; a passing lane with what it found.
+    const text = status === 'passed' ? (summary ?? reason) : (reason ?? summary);
+    return text ?? LANE_STATUS_LABEL[status];
+}
+function durationOf(startedAt, finishedAt) {
+    const ms = Date.parse(finishedAt) - Date.parse(startedAt);
+    return Number.isFinite(ms) && ms >= 0 ? ms : undefined;
+}
+/** Project a verify manifest onto the summary block. */
+export function verifySummary(manifest, reportPath) {
+    const lanes = [];
+    let budget;
+    for (const id of LANE_IDS) {
+        const lane = manifest.lanes[id];
+        if (!lane.selected)
+            continue;
+        lanes.push({
+            lane: id,
+            status: lane.status,
+            detail: laneDetail(lane.status, lane.summary, lane.reason),
+            costUsd: lane.usage.costUsd,
+            metered: lane.usage.metered,
+            limitUsd: lane.budget.limitUsd,
+            spentUsd: lane.budget.spentUsd,
+            exceeded: lane.budget.exceeded,
+        });
+        if (lane.budget.limitUsd !== undefined)
+            budget = (budget ?? 0) + lane.budget.limitUsd;
+    }
+    return {
+        status: manifest.aggregate.status,
+        headSha: shortSha(manifest.identity.intendedHeadSha ?? manifest.identity.checkoutSha),
+        durationMs: durationOf(manifest.startedAt, manifest.finishedAt),
+        lanes,
+        totalUsd: manifest.aggregate.costUsd,
+        budgetUsd: budget,
+        reportPath,
+    };
+}

package/dist/vision/cost.d.ts

@@ -1,4 +1,4 @@
-export type CallKind = 'ground' | 'heal' | 'assert' | 'code' | 'decide';
+export type CallKind = 'ground' | 'heal' | 'assert' | 'code' | 'decide' | 'explore';
 export interface CallCost {
     model: string;
     provider: string;

package/dist/vision/decisions.d.ts

@@ -1,6 +1,7 @@
+import { type ErrorCode } from '../ui/errors.js';
 import type { CallCost, ProviderValue } from './cost.js';
 /**
- * Pinned Jev slug — the alias `~typesafe/jev-latest` drifts silently and
+ * Pinned confidence-model slug — the alias `~typesafe/jev-latest` drifts silently and
  * adjudication thresholds are calibrated to a version. The alias stays
  * usable via `config.decisionModel` for experimentation.
  */
@@ -9,7 +10,12 @@ export type DecisionErrorKind = 'auth' | 'validation' | 'rate_limited' | 'overlo
 export declare class DecisionError extends Error {
     readonly kind: DecisionErrorKind;
     readonly retryable: boolean;
-    constructor(kind: DecisionErrorKind, message: string, retryable: boolean);
+    /** CLI error class (src/ui/errors.ts) when the failure has one: key, credit, rate, provider. */
+    readonly code?: ErrorCode | undefined;
+    readonly retryAfterSeconds?: number | undefined;
+    constructor(kind: DecisionErrorKind, message: string, retryable: boolean, 
+    /** CLI error class (src/ui/errors.ts) when the failure has one: key, credit, rate, provider. */
+    code?: ErrorCode | undefined, retryAfterSeconds?: number | undefined);
 }
 export interface NoulQuestion {
     type: 'noul';
@@ -52,7 +58,7 @@ export declare const isChoiceAnswer: (a: DecisionAnswer) => a is ChoiceAnswer;
 export declare const isScoreAnswer: (a: DecisionAnswer) => a is ScoreAnswer;
 /** Short error label for lane debug lines: DecisionError kind, else message. */
 export declare function describeDecisionError(e: unknown): string;
-/** Shared per-call batch cap for the Jev lanes (secrets, findings, triage). */
+/** Shared per-call batch cap for the confidence-model lanes (secrets, findings, triage). */
 export declare const MAX_CANDIDATES = 50;
 export interface DecisionClientOptions {
     apiKey: string;

package/dist/vision/decisions.js

@@ -1,7 +1,8 @@
 import { debug } from '../debug.js';
+import { classifyHttpStatus } from '../ui/errors.js';
 import { makeDecisionsCallCost } from './cost.js';
 /**
- * Pinned Jev slug — the alias `~typesafe/jev-latest` drifts silently and
+ * Pinned confidence-model slug — the alias `~typesafe/jev-latest` drifts silently and
  * adjudication thresholds are calibrated to a version. The alias stays
  * usable via `config.decisionModel` for experimentation.
  */
@@ -14,10 +15,16 @@ const MAX_SCORE_LEVELS = 10;
 export class DecisionError extends Error {
     kind;
     retryable;
-    constructor(kind, message, retryable) {
+    code;
+    retryAfterSeconds;
+    constructor(kind, message, retryable, 
+    /** CLI error class (src/ui/errors.ts) when the failure has one: key, credit, rate, provider. */
+    code, retryAfterSeconds) {
         super(message);
         this.kind = kind;
         this.retryable = retryable;
+        this.code = code;
+        this.retryAfterSeconds = retryAfterSeconds;
         this.name = 'DecisionError';
     }
 }
@@ -29,7 +36,7 @@ export const isScoreAnswer = (a) => 'score' in a;
 export function describeDecisionError(e) {
     return e instanceof DecisionError ? e.kind : e.message;
 }
-/** Shared per-call batch cap for the Jev lanes (secrets, findings, triage). */
+/** Shared per-call batch cap for the confidence-model lanes (secrets, findings, triage). */
 export const MAX_CANDIDATES = 50;
 function isRecord(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
@@ -98,23 +105,26 @@ function validateAnswers(questions, answers) {
     }
     return out;
 }
-function classifyStatus(status) {
-    if (status === 401 || status === 403) {
-        return new DecisionError('auth', `decide: HTTP ${status} — check OPENROUTER_API_KEY`, false);
-    }
+/**
+ * HTTP status to a typed DecisionError. `kind` and `retryable` drive the
+ * retry loop and stay as they were; the CLI class (`code`) and its message
+ * come from the shared classifier in src/ui/errors.ts.
+ */
+function classifyStatus(status, headers) {
+    const shared = classifyHttpStatus(status, headers);
+    const make = (kind, fallback, retryable) => new DecisionError(kind, shared !== undefined ? `decide: ${shared.message}` : fallback, retryable, shared?.code, shared?.retryAfterSeconds);
+    if (status === 401 || status === 403)
+        return make('auth', `decide: HTTP ${status}, check OPENROUTER_API_KEY`, false);
     if (status === 400 || status === 404 || status === 422) {
-        return new DecisionError('validation', `decide: HTTP ${status} — request rejected`, false);
-    }
-    if (status === 429) {
-        return new DecisionError('rate_limited', 'decide: HTTP 429 rate limited', true);
-    }
-    if (status === 503) {
-        return new DecisionError('overloaded', 'decide: HTTP 503 provider overloaded', true);
-    }
-    if (status >= 500) {
-        return new DecisionError('server_error', `decide: HTTP ${status}`, true);
+        return make('validation', `decide: HTTP ${status}, request rejected`, false);
     }
-    return new DecisionError('unexpected', `decide: HTTP ${status}`, false);
+    if (status === 429)
+        return make('rate_limited', 'decide: HTTP 429 rate limited', true);
+    if (status === 503)
+        return make('overloaded', 'decide: HTTP 503 provider overloaded', true);
+    if (status >= 500)
+        return make('server_error', `decide: HTTP ${status}`, true);
+    return make('unexpected', `decide: HTTP ${status}`, false);
 }
 function retryDelayMs(res) {
     const retryAfterMs = res.headers.get('retry-after-ms');
@@ -178,10 +188,10 @@ export class DecisionClient {
                     body: JSON.stringify(body),
                 });
                 if (!res.ok) {
-                    const err = classifyStatus(res.status);
+                    const err = classifyStatus(res.status, res.headers);
                     if (err.retryable && attempt === 0) {
                         const delay = retryDelayMs(res);
-                        debug('decisions', `${err.kind} — retrying in ${delay}ms`);
+                        debug('decisions', `${err.kind}, retrying in ${delay}ms`);
                         await new Promise((r) => setTimeout(r, delay));
                         continue;
                     }
@@ -215,7 +225,7 @@ export class DecisionClient {
                 if (err.name === 'AbortError') {
                     lastErr = new DecisionError('timeout', `decide: timed out after ${this._timeoutMs}ms`, true);
                     if (attempt === 0) {
-                        debug('decisions', 'timeout — retrying once');
+                        debug('decisions', 'timeout, retrying once');
                         continue;
                     }
                     break;