@wix/pathgrade 1.0.31 → 1.0.33

package/dist/reporters/verbose-emitter.js

@@ -10,18 +10,18 @@
  */
 import { fmt } from '../utils/cli.js';
 /** Maximum characters retained in a prompt/reply preview before truncation. */
-export const PREVIEW_MAX_CHARS = 80;
+const PREVIEW_MAX_CHARS = 80;
 /** Maximum characters retained in a retry error message before truncation. */
-export const RETRY_ERROR_MAX_CHARS = 120;
+const RETRY_ERROR_MAX_CHARS = 120;
 /** Ellipsis appended to truncated strings. */
-export const TRUNCATION_SUFFIX = '…';
+const TRUNCATION_SUFFIX = '…';
 /** Newline replacement in single-line previews. */
-export const NEWLINE_REPLACEMENT = '⏎';
+const NEWLINE_REPLACEMENT = '⏎';
 /**
  * Build a preview string: strip newlines, truncate to a max length.
  * `null` / `undefined` becomes an empty string so formatting never throws.
  */
-export function preview(text, max = PREVIEW_MAX_CHARS) {
+function preview(text, max = PREVIEW_MAX_CHARS) {
     const normalized = (text ?? '').replace(/\r?\n/g, NEWLINE_REPLACEMENT);
     if (normalized.length <= max)
         return normalized;

package/dist/reporting/types.d.ts

@@ -75,9 +75,10 @@ export interface ReportSummaryGroup {
     trial_count: number;
     diagnostics: ReportSummaryDiagnostics[];
 }
-export interface ReportSummaryDiagnostics {
+interface ReportSummaryDiagnostics {
     caseName: string;
     state: ReportCaseState;
     resultKind?: EvaluationResultKind;
     report: DiagnosticsReport;
 }
+export {};

package/dist/runners/adapter-loader.d.ts

@@ -2,9 +2,6 @@ import type { ResolvedPathgradeConfig } from '../config/pathgrade.js';
 import { type SpawnVitest } from './vitest-invocation.js';
 import type { RunnerAdapter } from './adapter.js';
 import type { RunnerInvocationAdapter } from './invocation.js';
-export interface ExternalAdapterFactoryInput {
-    config: ResolvedPathgradeConfig;
-}
 export declare function loadRunnerAdapter(input: {
     adapterName?: string;
     cwd?: string;

package/dist/runners/model-validation.d.ts

@@ -3,10 +3,11 @@ export interface NormalizedRunValidationResult {
     ok: boolean;
     errors: NormalizedRunValidationError[];
 }
-export interface NormalizedRunValidationError {
+interface NormalizedRunValidationError {
     path: string;
     message: string;
 }
 export declare function validateNormalizedRunSnapshot(snapshot: NormalizedRunSnapshot, options: {
     completeness: SnapshotCompleteness;
 }): NormalizedRunValidationResult;
+export {};

package/dist/runners/repeated-attempts.d.ts

@@ -1,7 +1,2 @@
 import type { NormalizedRunSnapshot } from './model.js';
-export type RepeatAggregationFailure = 'incomplete_attempts' | 'case_identity_mismatch';
-export declare class RepeatAggregationError extends Error {
-    readonly reason: RepeatAggregationFailure;
-    constructor(reason: RepeatAggregationFailure, message: string);
-}
 export declare function mergeRepeatedRunSnapshots(snapshots: readonly NormalizedRunSnapshot[]): NormalizedRunSnapshot;

package/dist/runners/repeated-attempts.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { validateNormalizedRunSnapshot } from './model-validation.js';
-export class RepeatAggregationError extends Error {
+class RepeatAggregationError extends Error {
     reason;
     constructor(reason, message) {
         super(message);

package/dist/runners/vitest-invocation.d.ts

@@ -1,5 +1,5 @@
 import type { RunnerInvocationAdapter } from './invocation.js';
-export interface SpawnVitestRequest {
+interface SpawnVitestRequest {
     argv: string[];
     env: NodeJS.ProcessEnv;
     cwd: string;
@@ -8,4 +8,4 @@ export type SpawnVitest = (req: SpawnVitestRequest) => Promise<number> | number;
 export declare function createVitestInvocationAdapter(input?: {
     spawnVitest?: SpawnVitest;
 }): RunnerInvocationAdapter;
-export declare function resolveVitestCli(cwd: string): string;
+export {};

package/dist/runners/vitest-invocation.js

@@ -47,7 +47,7 @@ async function defaultSpawnVitest(req) {
         child.on('close', code => resolve(code ?? 0));
     });
 }
-export function resolveVitestCli(cwd) {
+function resolveVitestCli(cwd) {
     const requireFromCwd = createRequire(path.join(cwd, 'package.json'));
     const packageJsonPath = requireFromCwd.resolve('vitest/package.json');
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));

package/dist/runners/vitest-lifecycle.d.ts

@@ -1,7 +1,6 @@
 import type { Agent, PathgradeTestMeta } from '../sdk/types.js';
 import { type ResultObserverHandle } from '../sdk/result-capture.js';
 import { type CaseContextProviderHandle } from '../sdk/case-context.js';
-import { type LifecycleAgentOwner } from '../sdk/lifecycle.js';
 import type { AdapterLifecycleHooks, EvalResultEvent } from './adapter.js';
 export type VitestAfterEachFn = (fn: (ctx: {
     task: {
@@ -31,7 +30,6 @@ export interface VitestLifecycleInstallHandle {
 }
 export declare function createVitestLifecycleHooks(): AdapterLifecycleHooks;
 export declare function installVitestLifecycle(input: VitestLifecycleInstallInput): VitestLifecycleInstallHandle;
-export declare function currentVitestAgentOwner(resultCaptureActive: boolean): LifecycleAgentOwner | null;
 export declare function trackVitestAgent(agent: Agent, resultCaptureActive: boolean): void;
 export declare function untrackVitestAgent(agent: Agent): void;
 export declare function releaseVitestAgent(agent: Agent): void;

package/dist/runners/vitest-lifecycle.js

@@ -43,7 +43,7 @@ export function installVitestLifecycle(input) {
         fileContextHandle.restore();
     }
 }
-export function currentVitestAgentOwner(resultCaptureActive) {
+function currentVitestAgentOwner(resultCaptureActive) {
     const current = getCurrentCaseContext();
     if (current.status === 'active') {
         return current.context.scope === 'runner-case'

package/dist/sdk/agent.js

@@ -261,9 +261,7 @@ class AgentImpl {
         const sendTurn = async (message) => {
             const turnResult = await ms.executeTurn(message);
             turnNumber++;
-            // Accumulate agent turn tokens (from CLI stream-json) on the shared tracker.
-            // Cost is populated by Claude SDK (from `total_cost_usd`); Codex/Cursor leave
-            // it undefined, in which case this is a no-op.
+            // Accumulate provider-reported agent turn tokens and cost on the shared tracker.
             this.accumulateTurnUsage(turnResult);
             for (const toolEvent of turnResult.toolEvents) {
                 this._log.push(buildToolEventLogEntry(toolEvent, new Date().toISOString()));

package/dist/sdk/ask-bus/handler.d.ts

@@ -1,12 +1,12 @@
 import type { AskHandler } from './types.js';
 import type { AskUserReactionPreviewEntry, Reaction } from '../types.js';
-export type UnmatchedAskUserDisposition = 'error' | 'first-option' | 'decline';
+type UnmatchedAskUserDisposition = 'error' | 'first-option' | 'decline';
 export interface AskUserHandlerContext {
     reactions: readonly Reaction[];
     onUnmatchedAskUser: UnmatchedAskUserDisposition;
     firedOnce: Set<number>;
 }
-export interface AskUserUnmatchedSignal {
+interface AskUserUnmatchedSignal {
     batchId: string;
     turnNumber: number;
     /**
@@ -29,3 +29,4 @@ export interface AskUserHandlerApi {
     getUnmatchedError(): AskUserUnmatchedSignal | null;
 }
 export declare function createAskUserHandler(ctx: AskUserHandlerContext): AskUserHandlerApi;
+export {};

package/dist/sdk/diagnostics.d.ts

@@ -1,7 +1,7 @@
 import type { LogEntry } from '../types.js';
 import type { ReactionFiredEntry, TurnDetail } from './types.js';
 import { type RuntimePolicyAuditEntry } from './runtime-policy.js';
-export interface DiagnosticsScorer {
+interface DiagnosticsScorer {
     name: string;
     type: string;
     score: number;
@@ -9,10 +9,10 @@ export interface DiagnosticsScorer {
     details?: string;
     status?: 'ok' | 'error' | 'skipped';
 }
-export interface DiagnosticsTurnDetail extends TurnDetail {
+interface DiagnosticsTurnDetail extends TurnDetail {
     apiRetries: number;
 }
-export type DiagnosticsRuntimePolicyEntry = RuntimePolicyAuditEntry;
+type DiagnosticsRuntimePolicyEntry = RuntimePolicyAuditEntry;
 export interface DiagnosticsReport {
     turns: number;
     totalDurationMs: number;
@@ -39,3 +39,4 @@ export interface BuildDiagnosticsReportInput {
     log: LogEntry[];
 }
 export declare function buildDiagnosticsReport(input: BuildDiagnosticsReportInput): DiagnosticsReport;
+export {};

package/dist/sdk/evaluate.js

@@ -68,8 +68,9 @@ function makeEvaluateAgent() {
             : undefined;
         // Agent usage is independent of the optional scorer LLM. Same
         // first-eval attribution rule for cost; omit it when unavailable.
-        // no conversation cost was captured (Codex / Cursor today).
-        const conversationCost = isFirstEval && beforeCostUsd > 0
+        // Preserve an authoritative zero while retaining compatibility with
+        // older/custom ports whose positive total is the only presence signal.
+        const conversationCost = isFirstEval && (agent.llm.costObserved === true || beforeCostUsd > 0)
             ? { conversation_cost_usd: beforeCostUsd }
             : undefined;
         if (isFirstEval)

package/dist/sdk/judge-tool-runner.d.ts

@@ -1,7 +1,6 @@
 import type { ToolCapableLLMPort } from '../utils/llm-types.js';
 import type { JudgeScorer, ScorerContext, ScorerResultEntry, TokenUsage } from './types.js';
-import { type JudgeErrorCode, type JudgeToolCallRecord, type ToolExecutor } from './judge-tool-session.js';
-export type { JudgeErrorCode, JudgeToolCallRecord };
+import { type JudgeToolCallRecord, type ToolExecutor } from './judge-tool-session.js';
 export interface RunJudgeWithToolsResult {
     entry: ScorerResultEntry;
     rounds: number;

package/dist/sdk/lifecycle.js

@@ -140,6 +140,7 @@ function synthesizeTrialFromAgent(agent) {
         return null;
     const nCommands = countShellCommandsFromLog(agent.log);
     const tokenUsage = agent.llm.tokenUsage;
+    const conversationCostUsd = agent.llm.costUsd ?? 0;
     const conversationEnd = [...agent.log].reverse().find((entry) => entry.type === 'conversation_end');
     const completionReason = conversationEnd?.completion_reason ?? (agent.log.some((entry) => entry.type === 'agent_result') ? 'completed' : undefined);
     return {
@@ -160,6 +161,9 @@ function synthesizeTrialFromAgent(agent) {
                     conversation_output_tokens: tokenUsage.outputTokens,
                 }
                 : {}),
+            ...(agent.llm.costObserved === true || conversationCostUsd > 0
+                ? { conversation_cost_usd: conversationCostUsd }
+                : {}),
             session_log: [...agent.log],
         },
         diagnostics: buildDiagnosticsReport({

package/dist/sdk/mcp-mock-approvals.d.ts

@@ -9,7 +9,7 @@ export interface McpMockApprovalRule {
     decision: 'approve' | 'deny';
     label?: string;
 }
-export interface CompiledMcpTool {
+interface CompiledMcpTool {
     name: string;
     description?: string;
     inputSchema: Record<string, unknown>;
@@ -19,7 +19,7 @@ export interface CompiledMcpTool {
         response: McpMockJsonValue;
     }>[];
 }
-export interface CompiledMcpServer {
+interface CompiledMcpServer {
     name: string;
     instructions?: string;
     tools: ReadonlyMap<string, CompiledMcpTool>;
@@ -38,3 +38,4 @@ export declare function matchesMcpApprovalArguments(actual: Record<string, McpMo
 export declare function canonicalizeMcpArguments(value: McpMockJsonValue): string;
 export declare function createMcpArgumentDigest(key: Buffer, value: McpMockJsonValue): string;
 export declare function createMcpReceiptKey(): Buffer;
+export {};

package/dist/sdk/reaction-loader.d.ts

@@ -1,4 +1,3 @@
-import type { AskUserOption, AskUserQuestion, AskUserReaction, Message, Reaction, TextReaction } from './types.js';
+import type { Message, Reaction } from './types.js';
 export declare function loadReactionSnapshotMessages(snapshotPath: string): Promise<Message[]>;
 export declare function loadReactionsFromFile(filePath: string): Promise<Reaction[]>;
-export type { AskUserOption, AskUserQuestion, AskUserReaction, TextReaction };

package/dist/sdk/reaction-preview.d.ts

@@ -1,6 +1,3 @@
-import type { AskUserReaction, Message, Reaction, ReactionPreviewEntry, ReactionPreviewResult, TextReaction } from './types.js';
-export declare function isAskUserReaction(reaction: Reaction): reaction is AskUserReaction;
-export declare function isTextReaction(reaction: Reaction): reaction is TextReaction;
+import type { Message, Reaction, ReactionPreviewEntry, ReactionPreviewResult } from './types.js';
 export declare function inspectReactions(agentMessage: string, reactions: Reaction[], firedOnce: Set<number>): ReactionPreviewEntry[];
-export declare function pickReactionReply(agentMessage: string, reactions: Reaction[], firedOnce: Set<number>): string | null;
 export declare function previewReactions(messages: Message[], reactions: Reaction[]): ReactionPreviewResult;

package/dist/sdk/reaction-preview.js

@@ -20,10 +20,10 @@ function testUnless(pattern, input) {
         return false;
     }
 }
-export function isAskUserReaction(reaction) {
+function isAskUserReaction(reaction) {
     return 'whenAsked' in reaction;
 }
-export function isTextReaction(reaction) {
+function isTextReaction(reaction) {
     return 'when' in reaction;
 }
 export function inspectReactions(agentMessage, reactions, firedOnce) {
@@ -71,7 +71,7 @@ export function inspectReactions(agentMessage, reactions, firedOnce) {
         };
     });
 }
-export function pickReactionReply(agentMessage, reactions, firedOnce) {
+function pickReactionReply(agentMessage, reactions, firedOnce) {
     const evaluations = inspectReactions(agentMessage, reactions, firedOnce);
     const match = evaluations.find((evaluation) => evaluation.fired && evaluation.kind === 'text');
     return match && match.kind === 'text' ? match.reply ?? null : null;

package/dist/sdk/run-scorer.d.ts

@@ -1,10 +1,7 @@
 import type { LLMPort } from '../utils/llm-types.js';
-import type { CheckScorer, Scorer, ScoreScorer, ScorerContext, ScorerResultEntry, ToolUsageScorer } from './types.js';
+import type { Scorer, ScorerContext, ScorerResultEntry } from './types.js';
 export interface RunScorerOptions {
     /** Required for `judge` scorers; ignored for other types. */
     llm?: LLMPort;
 }
 export declare function runScorer(scorer: Scorer, ctx: ScorerContext, opts?: RunScorerOptions): Promise<ScorerResultEntry>;
-export declare function runCheckScorer(scorer: CheckScorer, ctx: ScorerContext): Promise<ScorerResultEntry>;
-export declare function runScoreScorer(scorer: ScoreScorer, ctx: ScorerContext): Promise<ScorerResultEntry>;
-export declare function runToolUsageScorer(scorer: ToolUsageScorer, ctx: ScorerContext): Promise<ScorerResultEntry>;

package/dist/sdk/run-scorer.js

@@ -43,7 +43,7 @@ function buildEntryFromOutcome(scorer, outcome) {
         errorCode: outcome.code,
     };
 }
-export async function runCheckScorer(scorer, ctx) {
+async function runCheckScorer(scorer, ctx) {
     try {
         const passed = await scorer.fn(ctx);
         return {
@@ -59,7 +59,7 @@ export async function runCheckScorer(scorer, ctx) {
         return makeErroredResult('check', scorer.name, scorer.weight, error);
     }
 }
-export async function runScoreScorer(scorer, ctx) {
+async function runScoreScorer(scorer, ctx) {
     try {
         const raw = await scorer.fn(ctx);
         if (typeof raw === 'number') {
@@ -84,7 +84,7 @@ export async function runScoreScorer(scorer, ctx) {
         return makeErroredResult('score', scorer.name, scorer.weight, error);
     }
 }
-export async function runToolUsageScorer(scorer, ctx) {
+async function runToolUsageScorer(scorer, ctx) {
     try {
         const toolEvents = ctx.toolEvents;
         if (toolEvents.length === 0) {

package/dist/sdk/runtime-policy.d.ts

@@ -15,7 +15,6 @@ export interface RuntimePolicyAuditEntry {
 export declare const NONINTERACTIVE_RUNTIME_POLICY: RuntimePolicyDescriptor;
 export declare function planRuntimePolicies(agent: AgentName, transport?: AgentTransport): RuntimePolicyDescriptor[];
 export declare function renderRuntimePolicy(policy: RuntimePolicyDescriptor, context: RuntimePolicyRenderContext): string;
-export declare function renderRuntimePolicies(policies: RuntimePolicyDescriptor[], context: RuntimePolicyRenderContext): string;
 export declare function prependRuntimePolicies(instruction: string, policies: RuntimePolicyDescriptor[], context: RuntimePolicyRenderContext): string;
 export declare function getRuntimePolicyLogMetadata(turnResult: AgentTurnResult): Record<string, unknown>;
 export declare function extractRuntimePolicyAuditEntries(log: LogEntry[]): RuntimePolicyAuditEntry[];

package/dist/sdk/runtime-policy.js

@@ -32,7 +32,7 @@ export function renderRuntimePolicy(policy, context) {
         'Ask only the earliest outstanding approval checkpoint.',
     ].join('\n');
 }
-export function renderRuntimePolicies(policies, context) {
+function renderRuntimePolicies(policies, context) {
     return policies
         .map((policy) => renderRuntimePolicy(policy, context))
         .filter((policy) => policy.length > 0)

package/dist/tool-events.d.ts

@@ -44,7 +44,6 @@ export interface ToolEventResult {
     exitCode?: number;
     truncated?: boolean;
 }
-export declare function summarizeToolEvents(events: ToolEvent[]): string;
 /**
  * Map from provider-specific tool names to normalized Pathgrade actions.
  * Conservative: only map names we're confident about.

package/dist/tool-events.js

@@ -1,4 +1,4 @@
-export function summarizeToolEvents(events) {
+function summarizeToolEvents(events) {
     return events.map((event) => `${event.action}:${event.providerToolName}`).join(', ');
 }
 /**

package/dist/types.d.ts

@@ -8,10 +8,10 @@ export interface CommandResult {
     timedOut?: boolean;
     killed?: boolean;
 }
-export interface TurnCommand extends CommandResult {
+interface TurnCommand extends CommandResult {
     command: string;
 }
-export type ConversationReplySource = 'opener' | 'reaction' | 'persona_llm';
+type ConversationReplySource = 'opener' | 'reaction' | 'persona_llm';
 export interface ConversationTurn {
     turn_number: number;
     user_message: string;
@@ -24,7 +24,7 @@ export interface ConversationTurn {
     step_scorer_results?: ScorerResult[];
     tool_events?: import('./tool-events.js').ToolEvent[];
 }
-export type ConversationCompletionReason = 'max_turns' | 'signal' | 'done_phrase' | 'done_when' | 'timeout' | 'no_replies' | 'error';
+type ConversationCompletionReason = 'max_turns' | 'signal' | 'done_phrase' | 'done_when' | 'timeout' | 'no_replies' | 'error';
 export interface ScorerResult {
     scorer_type: string;
     score: number;
@@ -32,25 +32,7 @@ export interface ScorerResult {
     details: string;
     status?: import('./sdk/types.js').ScorerStatus;
 }
-/**
- * JSON contract for deterministic scorer stdout.
- * The scorer script must print a JSON object matching this shape to stdout.
- */
-export interface ScorerOutput {
-    /** Score between 0.0 and 1.0 (required). Clamped by pathgrade. */
-    score: number;
-    /** Human-readable summary (optional). */
-    details?: string;
-    /** Per-check breakdown, rendered as checkmarks in reports (optional). */
-    checks?: ScorerCheck[];
-}
-/** Individual check result within a ScorerOutput. */
-export interface ScorerCheck {
-    name: string;
-    passed: boolean;
-    message?: string;
-}
-export interface JudgeToolCallLogData {
+interface JudgeToolCallLogData {
     /** Tool name (readFile | listDir | grep | getToolEvents). */
     name: string;
     /** Arguments the LLM passed to the tool. */
@@ -103,8 +85,7 @@ export interface LogEntry {
     blocked_prompt_tool_use_id?: string;
     runtime_policies_applied?: RuntimePolicyDescriptor[];
     /**
-     * Per-turn agent cost in USD when the upstream provider reports it (the
-     * Claude Agent SDK populates `total_cost_usd` on result messages).
+     * Per-turn agent cost in USD when the executing agent reports or estimates it.
      * Written by `buildModelAgentResultLogEntry` only when the turn result
      * carries a `costUsd` value; absent for agents that do not expose cost.
      */
@@ -300,7 +281,7 @@ export interface PathgradeReport {
     selection?: PathgradeSelectionReport;
 }
 export type PassAtKUnavailableReason = 'non_binary_reward' | 'incomplete_attempts' | 'case_identity_mismatch';
-export interface TrialPaths {
+interface TrialPaths {
     root: string;
     workspace: string;
     home: string;
@@ -317,11 +298,11 @@ export interface TrialRuntime {
 }
 export type EnvironmentHandle = string | TrialRuntime;
 export type AgentCommandRunner = (cmd: string) => Promise<CommandResult>;
-export interface AgentTurnInput {
+interface AgentTurnInput {
     message: string;
     continueSession?: boolean;
 }
-export type VisibleAssistantMessageSource = 'assistant_message';
+type VisibleAssistantMessageSource = 'assistant_message';
 export interface AgentTurnResult {
     rawOutput: string;
     assistantMessage: string;
@@ -350,10 +331,7 @@ export interface AgentTurnResult {
      */
     cacheReadInputTokens?: number;
     /**
-     * Optional turn cost in USD reported by providers that expose exact
-     * pricing. The Claude Agent SDK populates this from the result
-     * message's `total_cost_usd`. Other drivers (Codex, Cursor) leave it
-     * undefined until their providers expose comparable metadata.
+     * Optional turn cost in USD reported or estimated by the executing agent.
      */
     costUsd?: number;
     /**
@@ -395,7 +373,6 @@ export interface AgentSession {
     dispose?(): Promise<void>;
 }
 export declare function getWorkspacePath(handle: EnvironmentHandle): string;
-export declare function getRuntimeHandle(handle: EnvironmentHandle): string;
 export declare function getRuntimeEnv(handle: EnvironmentHandle): Record<string, string>;
 export type McpConfigOrigin = 'generated_mock' | 'caller_config';
 export interface AgentSessionOptions {
@@ -449,3 +426,4 @@ export declare abstract class BaseAgent {
     run(_instruction: string, _workspacePath: string, _runCommand: AgentCommandRunner): Promise<string>;
 }
 export declare function createAgentSession(agent: BaseAgent, runtime: EnvironmentHandle, runCommand: AgentCommandRunner, options?: AgentSessionOptions): Promise<AgentSession>;
+export {};

package/dist/types.js

@@ -1,7 +1,7 @@
 export function getWorkspacePath(handle) {
     return typeof handle === 'string' ? handle : handle.workspacePath;
 }
-export function getRuntimeHandle(handle) {
+function getRuntimeHandle(handle) {
     return typeof handle === 'string' ? handle : handle.handle;
 }
 export function getRuntimeEnv(handle) {

package/dist/utils/cli.d.ts

@@ -15,21 +15,6 @@ export declare const fmt: {
 };
 /** Print a section header with a rule line */
 export declare function header(title: string, width?: number): void;
-/** Print a labeled key-value pair */
-export declare function kv(label: string, value: string, indent?: number): void;
-/** Print a trial result row */
-export declare function trialRow(trialId: number, total: number, reward: number, duration: string, commands: number, scorers: {
-    type: string;
-    score: number;
-}[]): void;
-/** Print the results summary block */
-export declare function resultsSummary(passRate: number, passAtK: number, passPowK: number, trials: number, preset?: string): void;
-/** Print a validation result */
-export declare function validationResult(passed: boolean, reward: number, scorers: {
-    type: string;
-    score: number;
-    details: string;
-}[]): void;
 /**
  * In-place spinner that shows current phase + elapsed time on one line.
  *

package/dist/utils/cli.js

@@ -27,13 +27,13 @@ export function header(title, width = 60) {
     console.log(`\n${fmt.bold(`── ${title} `)}${fmt.dim(rule)}`);
 }
 /** Print a labeled key-value pair */
-export function kv(label, value, indent = 2) {
+function kv(label, value, indent = 2) {
     const pad = ' '.repeat(indent);
     const labelPad = label.padEnd(12);
     console.log(`${pad}${fmt.dim(labelPad)}${value}`);
 }
 /** Print a trial result row */
-export function trialRow(trialId, total, reward, duration, commands, scorers) {
+function trialRow(trialId, total, reward, duration, commands, scorers) {
     const pad = '  ';
     const status = reward >= 0.5 ? fmt.pass('PASS') : fmt.fail('FAIL');
     const rewardStr = reward.toFixed(2);
@@ -47,7 +47,7 @@ export function trialRow(trialId, total, reward, duration, commands, scorers) {
     console.log(`${pad}  ${fmt.dim(trialLabel)} ${status}  ${fmt.bold(rewardStr)}  ${fmt.dim(duration.padEnd(7))} ${fmt.dim(commands + ' cmds')}  ${scorerStr}`);
 }
 /** Print the results summary block */
-export function resultsSummary(passRate, passAtK, passPowK, trials, preset) {
+function resultsSummary(passRate, passAtK, passPowK, trials, preset) {
     const presetLabel = preset === 'smoke' ? ' (smoke test)'
         : preset === 'reliable' ? ' (reliable)'
             : preset === 'regression' ? ' (regression)'
@@ -61,7 +61,7 @@ export function resultsSummary(passRate, passAtK, passPowK, trials, preset) {
     console.log();
 }
 /** Print a validation result */
-export function validationResult(passed, reward, scorers) {
+function validationResult(passed, reward, scorers) {
     for (const g of scorers) {
         const scoreStr = g.score.toFixed(2);
         const color = g.score >= 0.5 ? fmt.green(scoreStr) : fmt.red(scoreStr);

package/dist/utils/llm-mocks.d.ts

@@ -26,11 +26,11 @@ export interface CreateMockLLMOptions {
     /** When set, replaces the queue for `.call()`. Useful for dynamic / side-effecting tests. */
     respond?: (prompt: string, opts?: LLMCallOptions) => MockResponse | Promise<MockResponse>;
 }
-export interface MockCallRecord {
+interface MockCallRecord {
     prompt: string;
     opts?: LLMCallOptions;
 }
-export interface MockToolCallRecord {
+interface MockToolCallRecord {
     messages: ToolUseMessage[];
     opts: CallWithToolsOptions;
 }
@@ -41,3 +41,4 @@ export interface MockLLM extends LLMPort {
     readonly toolCalls: readonly MockToolCallRecord[];
 }
 export declare function createMockLLM(opts?: CreateMockLLMOptions): MockLLM;
+export {};

package/dist/utils/llm-mocks.js

@@ -12,6 +12,7 @@ export function createMockLLM(opts = {}) {
     let inputTokens = 0;
     let outputTokens = 0;
     let costUsd = 0;
+    let costObserved = false;
     let callCount = 0;
     const take = () => {
         callCount++;
@@ -29,6 +30,9 @@ export function createMockLLM(opts = {}) {
         get costUsd() {
             return costUsd;
         },
+        get costObserved() {
+            return costObserved;
+        },
         get supportsToolUse() {
             return true;
         },
@@ -43,6 +47,7 @@ export function createMockLLM(opts = {}) {
             if (!Number.isFinite(usd) || usd < 0)
                 return;
             costUsd += usd;
+            costObserved = true;
         },
         async measure(fn) {
             const inBefore = inputTokens;

package/dist/utils/llm-providers/cli.d.ts

@@ -3,7 +3,6 @@ import type { LLMProvider } from '../llm-types.js';
 export declare function resetCliCache(): void;
 /** Check if claude CLI is installed and authenticated. */
 export declare function isClaudeCliAvailable(): Promise<boolean>;
-export declare function isCodexCliAvailable(): Promise<boolean>;
 interface CliEnvelope {
     result?: string;
     structured_output?: unknown;

package/dist/utils/llm-providers/cli.js

@@ -27,7 +27,7 @@ export function resetCliCache() {
 export async function isClaudeCliAvailable() {
     return getCliAvailability('claude', ['auth', 'status'], 5);
 }
-export async function isCodexCliAvailable() {
+async function isCodexCliAvailable() {
     return getCliAvailability('codex', ['login', 'status'], 5);
 }
 export function parseCliEnvelope(raw) {

package/dist/utils/llm-types.d.ts

@@ -32,9 +32,11 @@ export interface LLMPort {
      * comparable metadata.
      */
     readonly costUsd?: number;
+    /** True after any valid cost observation, including an observed zero. */
+    readonly costObserved?: boolean;
     /** Add externally-observed tokens (e.g. from agent CLI turns). */
     addTokens?(input: number, output: number): void;
-    /** Add externally-observed cost (e.g. from Claude SDK `total_cost_usd`). */
+    /** Add externally-observed agent cost. */
     addCost?(usd: number): void;
     /** Run `fn` and return its token + cost delta. */
     measure?<T>(fn: () => Promise<T>): Promise<{
@@ -73,12 +75,12 @@ export interface ToolResultBlock {
     content: string;
     is_error?: boolean;
 }
-export interface TextBlock {
+interface TextBlock {
     type: 'text';
     text: string;
 }
-export type AssistantContentBlock = TextBlock | ToolUseBlock;
-export type UserContentBlock = TextBlock | ToolResultBlock;
+type AssistantContentBlock = TextBlock | ToolUseBlock;
+type UserContentBlock = TextBlock | ToolResultBlock;
 export interface ToolUseMessage {
     role: 'user' | 'assistant';
     content: string | Array<AssistantContentBlock | UserContentBlock>;
@@ -105,3 +107,4 @@ export interface LLMProviderAdapter {
 }
 /** @deprecated Use `LLMProviderAdapter`. Alias retained only during the RFC 010a migration. */
 export type LLMProvider = LLMProviderAdapter;
+export {};