@pugi/cli 0.1.0-beta.10 → 0.1.0-beta.101

package/dist/core/engine/verification-patterns.js

@@ -0,0 +1,195 @@
+/**
+ * PUGI-VERIFY-GATE — verification command detection.
+ *
+ * Background: Codex dogfood 2026-06-04 surfaced a P0 trust failure
+ * where the Pugi engine returned `status: done` + `exitCode: 0`
+ * even after `npm test` exited non-zero on a regression the agent
+ * itself had introduced. Root cause: no layer of the dispatch
+ * pipeline knew which bash invocations were verification commands,
+ * so the engine outcome had no way to gate the final status on
+ * test/lint/build pass.
+ *
+ * This module is the deterministic, configurable allowlist of regex
+ * patterns the engine uses to recognise verification commands at
+ * dispatch time. The detection is intentionally simple (anchored on
+ * the head of the command after sudo / env-prefix stripping) so the
+ * allowlist stays auditable. False negatives are recoverable (the
+ * agent can re-run with a recognised wrapper); false positives would
+ * silently down-grade unrelated commands and are forbidden.
+ *
+ * The pattern table is exported as `VERIFICATION_PATTERNS`; callers
+ * use `detectVerificationCommand(cmd)` for the boolean + tool-tag
+ * decision. Both surfaces are pure — no I/O, no session state, no
+ * environment reads.
+ */
+/**
+ * Canonical verification allowlist. Patterns target the head of each
+ * shell-separated component AFTER:
+ *   - leading whitespace is trimmed
+ *   - leading `sudo` / `time` / `env KEY=value` prefixes are stripped
+ *
+ * Pre-trim the cmd through `extractCommandHead` before matching.
+ *
+ * When extending: keep the regex anchored (`^`) so a path containing
+ * the tool name (`./scripts/npm.sh`) does not false-positive.
+ */
+export const VERIFICATION_PATTERNS = [
+    // ----- JavaScript / TypeScript ecosystem -----
+    // npm test / npm run test / npm run lint / npm run typecheck / npm run build
+    { tool: 'npm-test', pattern: /^npm\s+(?:run\s+)?test\b/, category: 'test' },
+    { tool: 'npm-lint', pattern: /^npm\s+run\s+lint\b/, category: 'lint' },
+    { tool: 'npm-typecheck', pattern: /^npm\s+run\s+typecheck\b/, category: 'typecheck' },
+    { tool: 'npm-build', pattern: /^npm\s+run\s+build\b/, category: 'build' },
+    // pnpm (with and without -C / --filter prefixes — match the full head)
+    { tool: 'pnpm-test', pattern: /^pnpm(?:\s+(?:-C\s+\S+|--filter(?:\s+|=)\S+|-r))*\s+(?:run\s+)?test\b/, category: 'test' },
+    { tool: 'pnpm-lint', pattern: /^pnpm(?:\s+(?:-C\s+\S+|--filter(?:\s+|=)\S+|-r))*\s+(?:run\s+)?lint\b/, category: 'lint' },
+    { tool: 'pnpm-typecheck', pattern: /^pnpm(?:\s+(?:-C\s+\S+|--filter(?:\s+|=)\S+|-r))*\s+(?:run\s+)?typecheck\b/, category: 'typecheck' },
+    { tool: 'pnpm-build', pattern: /^pnpm(?:\s+(?:-C\s+\S+|--filter(?:\s+|=)\S+|-r))*\s+(?:run\s+)?build\b/, category: 'build' },
+    // yarn
+    { tool: 'yarn-test', pattern: /^yarn\s+(?:run\s+)?test\b/, category: 'test' },
+    { tool: 'yarn-lint', pattern: /^yarn\s+(?:run\s+)?lint\b/, category: 'lint' },
+    { tool: 'yarn-typecheck', pattern: /^yarn\s+(?:run\s+)?typecheck\b/, category: 'typecheck' },
+    { tool: 'yarn-build', pattern: /^yarn\s+(?:run\s+)?build\b/, category: 'build' },
+    // Direct test-runner invocations (npx and bare).
+    { tool: 'jest', pattern: /^(?:npx\s+)?jest\b/, category: 'test' },
+    { tool: 'vitest', pattern: /^(?:npx\s+)?vitest\b/, category: 'test' },
+    { tool: 'mocha', pattern: /^(?:npx\s+)?mocha\b/, category: 'test' },
+    { tool: 'tsc-typecheck', pattern: /^(?:npx\s+)?tsc\b(?=.*--noEmit|\s*$)/, category: 'typecheck' },
+    { tool: 'eslint', pattern: /^(?:npx\s+)?eslint\b/, category: 'lint' },
+    { tool: 'node-test', pattern: /^node\s+--test\b/, category: 'test' },
+    // ----- Python -----
+    { tool: 'pytest', pattern: /^(?:python\s+-m\s+)?pytest\b/, category: 'test' },
+    { tool: 'python-unittest', pattern: /^python\s+-m\s+unittest\b/, category: 'test' },
+    { tool: 'ruff', pattern: /^ruff\s+check\b/, category: 'lint' },
+    { tool: 'mypy', pattern: /^mypy\b/, category: 'typecheck' },
+    // ----- Rust -----
+    { tool: 'cargo-test', pattern: /^cargo\s+test\b/, category: 'test' },
+    { tool: 'cargo-check', pattern: /^cargo\s+check\b/, category: 'typecheck' },
+    { tool: 'cargo-clippy', pattern: /^cargo\s+clippy\b/, category: 'lint' },
+    { tool: 'cargo-build', pattern: /^cargo\s+build\b/, category: 'build' },
+    // ----- Go -----
+    { tool: 'go-test', pattern: /^go\s+test\b/, category: 'test' },
+    { tool: 'go-vet', pattern: /^go\s+vet\b/, category: 'lint' },
+    { tool: 'go-build', pattern: /^go\s+build\b/, category: 'build' },
+    // ----- Elixir -----
+    { tool: 'mix-test', pattern: /^mix\s+test\b/, category: 'test' },
+    // ----- Ruby -----
+    { tool: 'rspec', pattern: /^(?:bundle\s+exec\s+)?rspec\b/, category: 'test' },
+    { tool: 'rubocop', pattern: /^(?:bundle\s+exec\s+)?rubocop\b/, category: 'lint' },
+    // ----- Java / Kotlin / Gradle / Maven -----
+    { tool: 'gradle-test', pattern: /^(?:\.\/)?gradlew?\s+test\b/, category: 'test' },
+    { tool: 'gradle-build', pattern: /^(?:\.\/)?gradlew?\s+build\b/, category: 'build' },
+    { tool: 'maven-test', pattern: /^mvn\s+test\b/, category: 'test' },
+    { tool: 'maven-verify', pattern: /^mvn\s+verify\b/, category: 'test' },
+    // ----- C/C++ / Make -----
+    { tool: 'make-test', pattern: /^make\s+(?:test|check)\b/, category: 'test' },
+    { tool: 'ctest', pattern: /^ctest\b/, category: 'test' },
+];
+const SHELL_SEPARATORS = /\s*(?:&&|\|\||;|\|)\s*/;
+const ENV_ASSIGN = /^[A-Z_][A-Z0-9_]*=\S+$/;
+/**
+ * Strip leading `sudo` / `time` / `env A=1 B=2` noise so the verb is
+ * the first non-prefix token. Returns the stripped head as a single
+ * normalised string. Pure — no side effects.
+ *
+ * We do NOT strip generic env-variable assignments like `CI=1` that
+ * the operator typed inline (e.g. `CI=1 pnpm test`) because the
+ * regex allowlist anchors `pnpm` — matching the head after stripping
+ * `CI=1` is precisely the intent.
+ */
+export function extractCommandHead(component) {
+    let head = component.trim();
+    // sudo / time wrappers
+    while (true) {
+        if (head.startsWith('sudo ')) {
+            head = head.slice(5).trimStart();
+            continue;
+        }
+        if (head.startsWith('time ')) {
+            head = head.slice(5).trimStart();
+            continue;
+        }
+        // env A=1 B=2 prefix (inline env assignments before the verb).
+        // Peel one token at a time so `FOO=bar BAZ=qux pnpm test` resolves to `pnpm test`.
+        const firstToken = head.split(/\s+/, 1)[0] ?? '';
+        if (firstToken !== '' && ENV_ASSIGN.test(firstToken)) {
+            head = head.slice(firstToken.length).trimStart();
+            continue;
+        }
+        break;
+    }
+    return head;
+}
+/**
+ * Detect whether a shell command runs a verification step. The
+ * predicate scans every `&&` / `;` / `||` / `|`-separated component
+ * and returns the first match — a compound command like
+ * `cd packages/foo && pnpm test` is correctly flagged on the
+ * trailing component.
+ *
+ * The check is intentionally optimistic: it does not parse `if`,
+ * `for`, or function bodies. Operators wrapping verification inside
+ * a script (e.g. `./scripts/test.sh`) opt out of the gate; that is
+ * recorded in the unverifiedReason as `no_verification_command_run`
+ * downstream.
+ */
+export function detectVerificationCommand(cmd) {
+    if (typeof cmd !== 'string' || cmd.trim() === '') {
+        return { isVerification: false, tool: null, matchedComponent: '' };
+    }
+    const components = cmd.split(SHELL_SEPARATORS);
+    for (const raw of components) {
+        const head = extractCommandHead(raw);
+        if (head === '')
+            continue;
+        for (const entry of VERIFICATION_PATTERNS) {
+            if (entry.pattern.test(head)) {
+                return {
+                    isVerification: true,
+                    tool: entry.tool,
+                    matchedComponent: raw.trim(),
+                };
+            }
+        }
+    }
+    return { isVerification: false, tool: null, matchedComponent: '' };
+}
+/**
+ * Phrases the agent uses to dispute ownership of a verification
+ * failure. When ANY of these phrases appears in the final assistant
+ * text AND the agent mutated files in the same module as a failing
+ * test, the outcome's `regressionOwnershipDispute` flag is set so a
+ * downstream reviewer can decide whether to escalate.
+ *
+ * The list is case-insensitive at match time. Punctuation around the
+ * phrase is allowed because `.includes()` looks for the substring,
+ * not word boundaries (an agent that writes "this is a pre-existing
+ * test bug" still trips the flag).
+ */
+export const REGRESSION_DISPUTE_PHRASES = [
+    'pre-existing',
+    'preexisting',
+    'pre existing',
+    'not from my changes',
+    'not related to my changes',
+    'unrelated test failure',
+    'unrelated to my changes',
+    'unrelated failure',
+    'not my change',
+];
+/**
+ * Tail trimmer for stderr captured in verification ledger entries.
+ * Returns the last `maxBytes` of UTF-8 text, clamped at a hard 2 KB
+ * default to match the PUGI-VERIFY-GATE contract.
+ */
+export function tailStderr(stderr, maxBytes = 2048) {
+    if (typeof stderr !== 'string' || stderr.length === 0)
+        return '';
+    if (Buffer.byteLength(stderr, 'utf8') <= maxBytes)
+        return stderr;
+    // Approximate cap by character index — accurate enough for stderr
+    // tails that are overwhelmingly ASCII test output.
+    const slice = stderr.slice(-maxBytes);
+    return slice;
+}
+//# sourceMappingURL=verification-patterns.js.map

package/dist/core/eval/v1/ledger.js

@@ -0,0 +1,83 @@
+/**
+ * Append-only TSV ledger for pugi-eval-v1 results.
+ *
+ * Pattern source: backlog #110 (Karpathy autoresearch). The ledger
+ * is git-tracked, never rewritten in place, never edited by hand. The
+ * column set is frozen as of schema v1; new columns must land in
+ * eval-v2 with a separate ledger file.
+ *
+ * Columns (tab-separated, in this exact order):
+ *
+ *   timestamp        UTC ISO 8601
+ *   git_sha          short sha of repo HEAD at run start
+ *   task_id          frozen task id (`NN-slug`)
+ *   model            engine model identifier or `(default)`
+ *   status           pass | fail | budget_exhausted | timeout | engine_error
+ *   pugi_score       per-task score, 2 decimal places
+ *   tokens           tokens reported by engine
+ *   turns            engine turn count
+ *   tool_calls       tool calls executed
+ *   wall_ms          wall-clock duration (ms)
+ *   exit_code        CLI subprocess exit code
+ *   verifications    `<passed>/<total>`
+ *
+ * Bytes containing TAB or NEWLINE are stripped from string fields
+ * before write so a single line is always one TSV record.
+ */
+import { appendFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+export const LEDGER_COLUMNS = [
+    'timestamp',
+    'git_sha',
+    'task_id',
+    'model',
+    'status',
+    'pugi_score',
+    'tokens',
+    'turns',
+    'tool_calls',
+    'wall_ms',
+    'exit_code',
+    'verifications',
+];
+export const LEDGER_HEADER = LEDGER_COLUMNS.join('\t');
+function safe(s) {
+    return s.replace(/[\t\r\n]+/g, ' ');
+}
+export function formatLedgerLine(row) {
+    const { timestamp, gitSha, model, result } = row;
+    const passed = result.verifications.filter((v) => v.passed).length;
+    const total = result.verifications.length;
+    const cells = [
+        safe(timestamp),
+        safe(gitSha),
+        safe(result.taskId),
+        safe(model),
+        safe(result.status),
+        result.pugiScore.toFixed(2),
+        String(result.tokensUsed),
+        String(result.turnsUsed),
+        String(result.toolCallCount),
+        String(result.wallClockMs),
+        String(result.exitCode),
+        `${passed}/${total}`,
+    ];
+    return cells.join('\t');
+}
+/**
+ * Append a single row. Creates the file with the header if it does
+ * not yet exist; otherwise appends a single line. Never rewrites
+ * existing content.
+ */
+export function appendLedgerRow(ledgerPath, row) {
+    mkdirSync(dirname(ledgerPath), { recursive: true });
+    if (!existsSync(ledgerPath)) {
+        writeFileSync(ledgerPath, `${LEDGER_HEADER}\n`, { mode: 0o644 });
+    }
+    appendFileSync(ledgerPath, `${formatLedgerLine(row)}\n`);
+}
+export function appendLedgerRows(ledgerPath, rows) {
+    for (const row of rows)
+        appendLedgerRow(ledgerPath, row);
+}
+//# sourceMappingURL=ledger.js.map

package/dist/core/eval/v1/runner.js

@@ -0,0 +1,280 @@
+/**
+ * Runner for pugi-eval-v1.
+ *
+ * Per task: spawn a fresh tmp workspace, copy fixture files, invoke
+ * the `pugi <command>` subprocess with the brief, capture stdout +
+ * exit code + wall-clock, then run the verification checks.
+ *
+ * The runner is deliberately subprocess-based - mirrors the smoke
+ * harness pattern in `core/smoke/headless-driver.ts`. Validating the
+ * AS-PUBLISHED CLI is the whole point of a benchmark; bypassing
+ * `bin/run.js` would let us miss whole categories of regression
+ * (loader cost, env propagation, exit-code handling).
+ *
+ * Tests inject a `runner` callback that returns a fake `RunCapture`
+ * so the meta-spec can exercise scoring + ledger without a real
+ * engine.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync, readdirSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { computePugiScore } from './scoring.js';
+import { runVerifications } from './verifier.js';
+/**
+ * Default executor: spawn `pugi <command> "<brief>" --json --print`
+ * inside the workspace. The `--print` flag forces non-interactive
+ * mode; `--json` produces the structured envelope the runner parses
+ * for `tokensUsed` etc.
+ */
+export const subprocessRunner = async (input) => {
+    const args = [
+        input.spec.command,
+        '--print',
+        '--json',
+        '--intensity',
+        input.spec.intensity,
+        '--max-turns',
+        String(input.spec.maxTurns),
+    ];
+    if (input.model) {
+        args.push('--model', input.model);
+    }
+    args.push(input.spec.brief);
+    const child = spawn(input.pugiBin, args, {
+        cwd: input.workspaceRoot,
+        env: input.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const start = Date.now();
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (chunk) => {
+        stdout += chunk.toString('utf8');
+    });
+    child.stderr?.on('data', (chunk) => {
+        stderr += chunk.toString('utf8');
+    });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+        timedOut = true;
+        try {
+            child.kill('SIGTERM');
+        }
+        catch {
+            /* noop */
+        }
+        setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                /* noop */
+            }
+        }, 5_000);
+    }, input.spec.timeoutMs);
+    const onAbort = () => {
+        try {
+            child.kill('SIGTERM');
+        }
+        catch {
+            /* noop */
+        }
+    };
+    input.signal?.addEventListener('abort', onAbort);
+    const exitCode = await new Promise((resolveExit) => {
+        child.on('exit', (code) => resolveExit(code ?? -1));
+        child.on('error', () => resolveExit(-1));
+    });
+    clearTimeout(timer);
+    input.signal?.removeEventListener('abort', onAbort);
+    const wallClockMs = Date.now() - start;
+    const parsed = parseEnvelope(stdout);
+    const budgetExhausted = parsed?.status === 'budget_exceeded' ||
+        parsed?.status === 'budget_exhausted';
+    const engineError = parsed?.status === 'engine_unavailable' ||
+        parsed?.status === 'failed';
+    return {
+        stdout,
+        stderr,
+        exitCode,
+        wallClockMs,
+        tokensUsed: parsed?.tokensUsed ?? 0,
+        turnsUsed: parsed?.turnsUsed ?? 0,
+        toolCallCount: parsed?.toolCallCount ?? 0,
+        timedOut,
+        budgetExhausted,
+        engineError,
+    };
+};
+/**
+ * Parse the last JSON envelope from stdout. Pugi `--json` emits one
+ * JSON object per invocation; the runner scans for the final `{...}`
+ * block so warning lines before it do not break parsing.
+ */
+function parseEnvelope(stdout) {
+    const trimmed = stdout.trim();
+    if (trimmed === '')
+        return null;
+    // Try the entire trimmed payload first (common case).
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        /* fall through to line scan */
+    }
+    const lines = trimmed.split(/\r?\n/);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i].trim();
+        if (!line.startsWith('{'))
+            continue;
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function walkFiles(root, prefix, out) {
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry === '.pugi' || entry === 'node_modules' || entry === '.git') {
+            continue;
+        }
+        const abs = join(root, entry);
+        const rel = prefix === '' ? entry : `${prefix}/${entry}`;
+        let st;
+        try {
+            st = statSync(abs);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            walkFiles(abs, rel, out);
+        }
+        else if (st.isFile()) {
+            out.push(rel);
+        }
+    }
+}
+function classifyStatus(capture, verificationsAllPassed) {
+    if (capture.timedOut)
+        return 'timeout';
+    if (capture.budgetExhausted)
+        return 'budget_exhausted';
+    if (capture.engineError)
+        return 'engine_error';
+    if (capture.exitCode !== 0)
+        return 'fail';
+    return verificationsAllPassed ? 'pass' : 'fail';
+}
+export function prepareWorkspace(spec) {
+    const root = mkdtempSync(join(tmpdir(), `pugi-eval-v1-${spec.id}-`));
+    if (spec.fixture) {
+        for (const [relPath, body] of Object.entries(spec.fixture)) {
+            if (relPath.split(/[\\/]/).includes('..')) {
+                throw new Error(`eval-v1 task ${spec.id}: fixture path ${relPath} contains ..`);
+            }
+            const abs = resolve(root, relPath);
+            mkdirSync(dirname(abs), { recursive: true });
+            writeFileSync(abs, body, { mode: 0o644 });
+        }
+    }
+    const cleanup = () => {
+        try {
+            rmSync(root, { recursive: true, force: true });
+        }
+        catch {
+            /* swallow */
+        }
+    };
+    return { root, cleanup };
+}
+export async function runTaskWithCapture(spec, workspaceRoot, capture) {
+    const parsed = parseEnvelope(capture.stdout);
+    const finalText = parsed?.finalText ?? capture.stdout;
+    const verifications = runVerifications(spec.verification, {
+        workspaceRoot,
+        finalText,
+    });
+    const allPassed = verifications.every((v) => v.passed);
+    const status = classifyStatus(capture, allPassed);
+    const filesWritten = [];
+    walkFiles(workspaceRoot, '', filesWritten);
+    filesWritten.sort();
+    const base = {
+        taskId: spec.id,
+        status,
+        tokensUsed: capture.tokensUsed,
+        toolCallCount: capture.toolCallCount,
+        turnsUsed: capture.turnsUsed,
+        wallClockMs: capture.wallClockMs,
+        exitCode: capture.exitCode,
+        verifications,
+        finalText,
+        filesWritten,
+    };
+    const pugiScore = computePugiScore(base, spec);
+    return { ...base, pugiScore };
+}
+export async function runOneTask(spec, options) {
+    const ws = prepareWorkspace(spec);
+    try {
+        const capture = await options.runner({
+            spec,
+            workspaceRoot: ws.root,
+            pugiBin: options.pugiBin,
+            ...(options.model !== undefined ? { model: options.model } : {}),
+            env: options.env,
+            ...(options.signal !== undefined ? { signal: options.signal } : {}),
+        });
+        return await runTaskWithCapture(spec, ws.root, capture);
+    }
+    finally {
+        ws.cleanup();
+    }
+}
+export async function runHarness(input) {
+    const runner = input.options.runner ?? subprocessRunner;
+    const env = input.options.env ?? process.env;
+    const onlyFilter = input.options.only
+        ? new Set(input.options.only)
+        : null;
+    const out = [];
+    for (const spec of input.specs) {
+        if (onlyFilter && !onlyFilter.has(spec.id))
+            continue;
+        input.options.onTaskStart?.(spec);
+        const runOpts = {
+            pugiBin: input.options.pugiBin,
+            env,
+            runner,
+        };
+        if (input.options.model !== undefined) {
+            runOpts.model = input.options.model;
+        }
+        const result = await runOneTask(spec, runOpts);
+        out.push(result);
+        input.options.onTaskFinish?.(result);
+    }
+    if (onlyFilter && out.length === 0) {
+        throw new Error(`eval-v1: --task filter matched zero tasks (asked for ${[...onlyFilter].join(', ')})`);
+    }
+    // Verify path safety: workspace cleanup happened, no temp dirs
+    // leaked beyond tmpdir prefix.
+    if (!existsSync(tmpdir())) {
+        // pathological - tmpdir disappeared. Surface so CI fails loud.
+        throw new Error('eval-v1: tmpdir no longer exists post-run');
+    }
+    return out;
+}
+//# sourceMappingURL=runner.js.map

package/dist/core/eval/v1/scoring.js

@@ -0,0 +1,68 @@
+/**
+ * pugi_score scoring formula for eval-v1.
+ *
+ * Per-task score (0..150, higher = better):
+ *
+ *   pugi_score = pass_rate                           * 100   // 0..100
+ *              + verification_completeness           *  50   // 0.. 50
+ *              - (tokens_used   / max_tokens)        *  30   // 0..-30
+ *              - (wall_clock_ms / timeout_ms)        *  20   // 0..-20
+ *
+ * Where:
+ *   - `pass_rate` is 1.0 if status is `pass`, 0 otherwise.
+ *   - `verification_completeness` is `passed_checks / total_checks`.
+ *   - Token and wall-clock penalties are clamped to [0, 1] so a run
+ *     that exceeds the budget cap caps the penalty (avoid runaway
+ *     negative scores that would skew the aggregate).
+ *
+ * Aggregate is the arithmetic mean across all per-task scores. Mean
+ * is defensible because every task contributes equally to the
+ * benchmark (we are not weighting by difficulty - eval-v2 may add
+ * weights once we have a baseline year of data).
+ */
+const PASS_WEIGHT = 100;
+const VERIFICATION_WEIGHT = 50;
+const TOKEN_PENALTY = 30;
+const WALL_PENALTY = 20;
+function clamp01(n) {
+    if (!Number.isFinite(n))
+        return 1;
+    if (n < 0)
+        return 0;
+    if (n > 1)
+        return 1;
+    return n;
+}
+/**
+ * Compute the per-task pugi_score. Called by the runner before
+ * appending the result to the ledger.
+ */
+export function computePugiScore(result, spec) {
+    const passRate = result.status === 'pass' ? 1 : 0;
+    const totalChecks = Math.max(1, result.verifications.length);
+    const passedChecks = result.verifications.filter((v) => v.passed).length;
+    const completeness = passedChecks / totalChecks;
+    const tokenPenalty = clamp01(result.tokensUsed / spec.maxTokens);
+    const wallPenalty = clamp01(result.wallClockMs / spec.timeoutMs);
+    const score = passRate * PASS_WEIGHT +
+        completeness * VERIFICATION_WEIGHT -
+        tokenPenalty * TOKEN_PENALTY -
+        wallPenalty * WALL_PENALTY;
+    // Clamp к [0, 150] so a partial-completeness fail with non-zero
+    // penalties never produces a negative aggregate. The penalties are
+    // already clamped to [0, 1] individually; this final clamp protects
+    // the documented range invariant when verification_completeness is
+    // 0 AND budget penalties land.
+    const clamped = Math.max(0, Math.min(150, score));
+    return Math.round(clamped * 100) / 100;
+}
+/**
+ * Aggregate score across an entire harness run. Mean by design.
+ */
+export function aggregateScore(results) {
+    if (results.length === 0)
+        return 0;
+    const sum = results.reduce((acc, r) => acc + r.pugiScore, 0);
+    return Math.round((sum / results.length) * 100) / 100;
+}
+//# sourceMappingURL=scoring.js.map