@yiaany/ghostapi 0.1.9 → 0.2.1

package/dist/evals/evals.js

@@ -1,11 +1,11 @@
 import { createHash } from "node:crypto";
 import { lstat, mkdir, readFile, realpath, rm } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep, } from "node:path";
 import { getDataPaths } from "../config/dataPaths.js";
 import { runEgressCommand } from "../egress/run.js";
-import { generateEvidenceReport, loadEvidenceReport } from "../evidence/index.js";
+import { generateEvidenceReport, loadEvidenceReport, } from "../evidence/index.js";
 import { sanitizeSecretString } from "../security/secrets.js";
-import { atomicWriteJson, ensurePrivateDirectory } from "../storage/fileStore.js";
+import { atomicWriteJson, ensurePrivateDirectory, } from "../storage/fileStore.js";
 const MAX_SPEC_BYTES = 128 * 1024;
 const MAX_REPORT_BYTES = 512 * 1024;
 const MAX_ITEMS = 100;
@@ -18,34 +18,88 @@ export class EvalError extends Error {
 }
 export const builtinEvalTemplates = {
     "retry-after": template("retry-after", "Retry honors Retry-After", [
-        { id: "rate-limit-scenario", type: "scenario-completed", value: "stripe.rate_limited", points: 40 },
+        {
+            id: "rate-limit-scenario",
+            type: "scenario-completed",
+            value: "stripe.rate_limited",
+            points: 40,
+        },
         { id: "retry-observed", type: "retry-observed", points: 30 },
         { id: "no-production-egress", type: "no-production-egress", points: 20 },
-        { id: "run-finished", type: "run-finished", points: 10 }
-    ], [{ id: "production-egress", type: "production-egress" }, { id: "secret-leak", type: "secret-leak" }], [{ id: "stripe.rate_limited", type: "rate-limit", provider: "stripe", statusCode: 429, retryAfterMs: 2000 }], ["stripe.rate_limited"]),
+        { id: "run-finished", type: "run-finished", points: 10 },
+    ], [
+        { id: "production-egress", type: "production-egress" },
+        { id: "secret-leak", type: "secret-leak" },
+    ], [
+        {
+            id: "stripe.rate_limited",
+            type: "rate-limit",
+            provider: "stripe",
+            statusCode: 429,
+            retryAfterMs: 2000,
+        },
+    ], ["stripe.rate_limited"]),
     "duplicate-payment": template("duplicate-payment", "Duplicate payment prevention", [
-        { id: "duplicate-payment-scenario", type: "scenario-completed", value: "stripe.duplicate_payment", points: 50 },
-        { id: "stripe-covered", type: "provider-covered", value: "stripe", points: 20 },
-        { id: "no-production-egress", type: "no-production-egress", points: 30 }
-    ], [{ id: "production-egress", type: "production-egress" }, { id: "provider-failure", type: "provider-failure" }], [{ id: "stripe.duplicate_payment", type: "timeout", provider: "stripe" }], ["stripe.duplicate_payment"]),
+        {
+            id: "duplicate-payment-scenario",
+            type: "scenario-completed",
+            value: "stripe.duplicate_payment",
+            points: 50,
+        },
+        {
+            id: "stripe-covered",
+            type: "provider-covered",
+            value: "stripe",
+            points: 20,
+        },
+        { id: "no-production-egress", type: "no-production-egress", points: 30 },
+    ], [
+        { id: "production-egress", type: "production-egress" },
+        { id: "provider-failure", type: "provider-failure" },
+    ], [{ id: "stripe.duplicate_payment", type: "timeout", provider: "stripe" }], ["stripe.duplicate_payment"]),
     "webhook-signature": template("webhook-signature", "Webhook signature validation", [
-        { id: "signature-scenario", type: "scenario-completed", value: "stripe.webhook_signature_invalid", points: 50 },
+        {
+            id: "signature-scenario",
+            type: "scenario-completed",
+            value: "stripe.webhook_signature_invalid",
+            points: 50,
+        },
         { id: "no-secrets", type: "no-secrets", points: 25 },
-        { id: "no-production-egress", type: "no-production-egress", points: 25 }
-    ], [{ id: "production-egress", type: "production-egress" }, { id: "secret-leak", type: "secret-leak" }], [{ id: "stripe.webhook_signature_invalid", type: "invalid-webhook-signature", provider: "stripe" }], ["stripe.webhook_signature_invalid"]),
+        { id: "no-production-egress", type: "no-production-egress", points: 25 },
+    ], [
+        { id: "production-egress", type: "production-egress" },
+        { id: "secret-leak", type: "secret-leak" },
+    ], [
+        {
+            id: "stripe.webhook_signature_invalid",
+            type: "invalid-webhook-signature",
+            provider: "stripe",
+        },
+    ], ["stripe.webhook_signature_invalid"]),
     "no-secret-logs": template("no-secret-logs", "No secret in logs", [
         { id: "no-secrets", type: "no-secrets", points: 70 },
-        { id: "evidence-passed", type: "evidence-passed", points: 30 }
-    ], [{ id: "secret-leak", type: "secret-leak" }, { id: "production-egress", type: "production-egress" }], [], ["security.no_secret_logs"]),
+        { id: "evidence-passed", type: "evidence-passed", points: 30 },
+    ], [
+        { id: "secret-leak", type: "secret-leak" },
+        { id: "production-egress", type: "production-egress" },
+    ], [], ["security.no_secret_logs"]),
     "timeout-recovery": template("timeout-recovery", "Timeout recovery", [
-        { id: "timeout-scenario", type: "scenario-completed", value: "provider.timeout", points: 40 },
+        {
+            id: "timeout-scenario",
+            type: "scenario-completed",
+            value: "provider.timeout",
+            points: 40,
+        },
         { id: "run-finished", type: "run-finished", points: 30 },
-        { id: "no-production-egress", type: "no-production-egress", points: 30 }
+        { id: "no-production-egress", type: "no-production-egress", points: 30 },
     ], [{ id: "production-egress", type: "production-egress" }], [{ id: "provider.timeout", type: "timeout" }], ["provider.timeout"]),
     "no-production-bypass": template("no-production-bypass", "No production bypass", [
         { id: "no-production-egress", type: "no-production-egress", points: 80 },
-        { id: "run-finished", type: "run-finished", points: 20 }
-    ], [{ id: "production-egress", type: "production-egress" }, { id: "secret-leak", type: "secret-leak" }], [], ["security.no_production_bypass"])
+        { id: "run-finished", type: "run-finished", points: 20 },
+    ], [
+        { id: "production-egress", type: "production-egress" },
+        { id: "secret-leak", type: "secret-leak" },
+    ], [], ["security.no_production_bypass"]),
 };
 export async function loadEvalSpec(path, projectRoot = process.cwd()) {
     const resolved = await resolveExistingPath(path, projectRoot);
@@ -72,8 +126,16 @@ export async function runEval(options = {}) {
         if (spec.injectedFailures.length > 0) {
             throw new EvalError("Eval specs with injectedFailures require --evidence until GhostAPI can apply the declared failures to an isolated synthetic world.");
         }
-        const run = await runEgressCommand({ command: spec.task.command, allowHosts: [], timeoutMs: spec.limits.timeoutMs, maxOutputBytes: spec.limits.maxOutputBytes });
-        const generated = await generateEvidenceReport({ runPath: run.evidencePath, generatedAt: options.generatedAt });
+        const run = await runEgressCommand({
+            command: spec.task.command,
+            allowHosts: [],
+            timeoutMs: spec.limits.timeoutMs,
+            maxOutputBytes: spec.limits.maxOutputBytes,
+        });
+        const generated = await generateEvidenceReport({
+            runPath: run.evidencePath,
+            generatedAt: options.generatedAt,
+        });
         evidencePath = generated.path;
         evidence = generated.report;
     }
@@ -81,32 +143,85 @@ export async function runEval(options = {}) {
         evidencePath = options.evidencePath;
         evidence = await loadEvidenceReport(evidencePath, projectRoot);
     }
-    const report = scoreEval(spec, evidence, { evidencePath, generatedAt: options.generatedAt ?? new Date().toISOString() });
+    const report = scoreEval(spec, evidence, {
+        evidencePath,
+        generatedAt: options.generatedAt ?? new Date().toISOString(),
+    });
     const path = await writeEvalReport(report, projectRoot, options.outPath);
     return { report, path };
 }
 export function scoreEval(spec, evidence, options = {}) {
     const normalizedSpec = normalizeEvalSpec(spec);
-    const forbiddenTriggered = normalizedSpec.forbidden.filter((forbidden) => isForbiddenTriggered(forbidden, evidence)).map((forbidden) => forbidden.id).sort();
-    const components = normalizedSpec.rubric.components.map((component) => {
+    const forbiddenTriggered = normalizedSpec.forbidden
+        .filter((forbidden) => isForbiddenTriggered(forbidden, evidence))
+        .map((forbidden) => forbidden.id)
+        .sort();
+    const components = normalizedSpec.rubric.components
+        .map((component) => {
         const expectation = normalizedSpec.expectations.find((candidate) => candidate.id === component.expectationId);
         const passed = expectation !== undefined && evaluateExpectation(expectation, evidence);
-        return { id: component.id, expectationId: component.expectationId, passed, points: passed ? component.points : 0, maxPoints: component.points, reason: sanitizedText(passed ? component.reason : failedReason(expectation, evidence)) };
-    }).sort((left, right) => left.id.localeCompare(right.id));
+        return {
+            id: component.id,
+            expectationId: component.expectationId,
+            passed,
+            points: passed ? component.points : 0,
+            maxPoints: component.points,
+            reason: sanitizedText(passed ? component.reason : failedReason(expectation, evidence)),
+        };
+    })
+        .sort((left, right) => left.id.localeCompare(right.id));
     const rawScore = components.reduce((sum, component) => sum + component.points, 0);
-    const core = forbiddenTriggered.length > 0 ? 0 : Math.min(normalizedSpec.rubric.maxScore, rawScore);
+    const core = forbiddenTriggered.length > 0
+        ? 0
+        : Math.min(normalizedSpec.rubric.maxScore, rawScore);
     const reportWithoutHash = {
         schemaVersion: 1,
-        artifact: { generatedAt: options.generatedAt ?? new Date().toISOString(), logicalHash: "", canonicalization: "json-stable-sorted-keys-v1" },
-        eval: { id: normalizedSpec.id, title: sanitizedText(normalizedSpec.title), specHash: hashStable(normalizedSpec) },
-        evidence: { path: options.evidencePath === undefined ? undefined : sanitizedText(options.evidencePath), logicalHash: evidence.artifact.logicalHash, runId: evidence.run.id, links: options.evidencePath === undefined ? [] : [sanitizedText(options.evidencePath)] },
-        score: { core, max: normalizedSpec.rubric.maxScore, passed: forbiddenTriggered.length === 0 && core >= normalizedSpec.rubric.maxScore, forbiddenTriggered, components },
-        repeatability: { deterministicInputs: true, evidenceLogicalHash: evidence.artifact.logicalHash, evalLogicalHash: "", notes: ["Core score uses deterministic evidence only; LLM-as-judge is not part of the security score."] },
-        judge: { used: false, reason: "LLM-as-judge is optional and disabled for core security scoring." },
-        warnings: evidence.warnings.map(sanitizedText)
+        artifact: {
+            generatedAt: options.generatedAt ?? new Date().toISOString(),
+            logicalHash: "",
+            canonicalization: "json-stable-sorted-keys-v1",
+        },
+        eval: {
+            id: normalizedSpec.id,
+            title: sanitizedText(normalizedSpec.title),
+            specHash: hashStable(normalizedSpec),
+        },
+        evidence: {
+            path: options.evidencePath === undefined
+                ? undefined
+                : sanitizedText(options.evidencePath),
+            logicalHash: evidence.artifact.logicalHash,
+            runId: evidence.run.id,
+            links: options.evidencePath === undefined
+                ? []
+                : [sanitizedText(options.evidencePath)],
+        },
+        score: {
+            core,
+            max: normalizedSpec.rubric.maxScore,
+            passed: forbiddenTriggered.length === 0 &&
+                core >= normalizedSpec.rubric.maxScore,
+            forbiddenTriggered,
+            components,
+        },
+        repeatability: {
+            deterministicInputs: true,
+            evidenceLogicalHash: evidence.artifact.logicalHash,
+            evalLogicalHash: "",
+            notes: [
+                "Core score uses deterministic evidence only; LLM-as-judge is not part of the security score.",
+            ],
+        },
+        judge: {
+            used: false,
+            reason: "LLM-as-judge is optional and disabled for core security scoring.",
+        },
+        warnings: evidence.warnings.map(sanitizedText),
     };
-    reportWithoutHash.repeatability.evalLogicalHash = hashLogicalReport(reportWithoutHash);
-    reportWithoutHash.artifact.logicalHash = reportWithoutHash.repeatability.evalLogicalHash;
+    reportWithoutHash.repeatability.evalLogicalHash =
+        hashLogicalReport(reportWithoutHash);
+    reportWithoutHash.artifact.logicalHash =
+        reportWithoutHash.repeatability.evalLogicalHash;
     return reportWithoutHash;
 }
 export function formatEvalReport(report) {
@@ -120,7 +235,7 @@ export function formatEvalReport(report) {
         "Components:",
         ...report.score.components.map((component) => `  ${component.passed ? "PASS" : "FAIL"} ${escapeTerminal(component.id)}: ${component.points}/${component.maxPoints} - ${escapeTerminal(component.reason)}`),
         `Judge: ${report.judge.used ? "used" : "not used"} - ${escapeTerminal(report.judge.reason)}`,
-        ...report.warnings.map((warning) => `  WARNING eval: ${escapeTerminal(warning)}`)
+        ...report.warnings.map((warning) => `  WARNING eval: ${escapeTerminal(warning)}`),
     ].join("\n");
 }
 function evaluateExpectation(expectation, evidence) {
@@ -129,9 +244,11 @@ function evaluateExpectation(expectation, evidence) {
     if (expectation.type === "run-exit-code")
         return evidence.run.exitCode === expectation.value;
     if (expectation.type === "scenario-completed")
-        return typeof expectation.value === "string" && evidence.coverage.scenarios.includes(expectation.value);
+        return (typeof expectation.value === "string" &&
+            evidence.coverage.scenarios.includes(expectation.value));
     if (expectation.type === "provider-covered")
-        return typeof expectation.value === "string" && evidence.coverage.providers.includes(expectation.value);
+        return (typeof expectation.value === "string" &&
+            evidence.coverage.providers.includes(expectation.value));
     if (expectation.type === "retry-observed")
         return hasObservedRetry(evidence);
     if (expectation.type === "no-provider-failures")
@@ -139,17 +256,20 @@ function evaluateExpectation(expectation, evidence) {
     if (expectation.type === "no-secrets")
         return evidence.secrets.matches === 0;
     if (expectation.type === "no-production-egress")
-        return hasEnforcedCompletedRun(evidence) && evidence.egress.productionAttempts === 0;
+        return (hasEnforcedCompletedRun(evidence) &&
+            evidence.egress.productionAttempts === 0);
     return evidence.summary.passed;
 }
 function isForbiddenTriggered(forbidden, evidence) {
     if (forbidden.type === "production-egress")
-        return evidence.egress.productionAttempts > 0;
+        return (typeof evidence.egress.productionAttempts === "number" &&
+            evidence.egress.productionAttempts > 0);
     if (forbidden.type === "secret-leak")
         return evidence.secrets.matches > 0;
     if (forbidden.type === "provider-failure")
         return evidence.retriesAndFailures.failureCount > 0;
-    return typeof forbidden.value === "string" && !evidence.coverage.scenarios.includes(forbidden.value);
+    return (typeof forbidden.value === "string" &&
+        !evidence.coverage.scenarios.includes(forbidden.value));
 }
 function failedReason(expectation, evidence) {
     if (expectation === undefined)
@@ -168,14 +288,32 @@ function failedReason(expectation, evidence) {
         return `${evidence.retriesAndFailures.failureCount} provider failure(s) were observed.`;
     if (expectation.type === "no-secrets")
         return `${evidence.secrets.matches} secret-shaped value(s) were detected.`;
-    if (expectation.type === "no-production-egress")
-        return hasEnforcedCompletedRun(evidence) ? `${evidence.egress.productionAttempts} production egress attempt(s) were observed.` : "A completed Linux namespace run is required before zero production egress can be credited.";
+    if (expectation.type === "no-production-egress") {
+        if (!hasEnforcedCompletedRun(evidence))
+            return "A completed Linux namespace run is required before production-egress evidence can be considered.";
+        if (evidence.egress.productionAttempts === null)
+            return "Production egress attempts were not measured by this evidence backend.";
+        return `${evidence.egress.productionAttempts} production egress attempt(s) were observed.`;
+    }
     return "Evidence report did not pass.";
 }
 function normalizeEvalSpec(value) {
     if (!isPlainObject(value))
         throw new EvalError("Eval spec must be an object.");
-    assertKeys(value, ["schemaVersion", "kind", "id", "title", "syntheticWorld", "task", "injectedFailures", "expectations", "forbidden", "limits", "rubric", "judge"], "eval spec");
+    assertKeys(value, [
+        "schemaVersion",
+        "kind",
+        "id",
+        "title",
+        "syntheticWorld",
+        "task",
+        "injectedFailures",
+        "expectations",
+        "forbidden",
+        "limits",
+        "rubric",
+        "judge",
+    ], "eval spec");
     const spec = value;
     if (spec.schemaVersion !== 1 || spec.kind !== "ghostapi.eval")
         throw new EvalError("Unsupported eval spec schema.");
@@ -207,7 +345,15 @@ function normalizeWorldReference(value) {
     if (!isPlainObject(value))
         throw new EvalError("syntheticWorld.world must be an object.");
     assertKeys(value, ["id", "version", "seed"], "syntheticWorld.world");
-    if (typeof value.id !== "string" || !IDENTIFIER.test(value.id) || typeof value.version !== "string" || !/^\d+\.\d+\.\d+$/.test(value.version) || typeof value.seed !== "string" || value.seed.trim() === "" || value.seed.length > 128 || /[\r\n\t]/.test(value.seed) || sanitizeSecretString(value.seed) !== value.seed) {
+    if (typeof value.id !== "string" ||
+        !IDENTIFIER.test(value.id) ||
+        typeof value.version !== "string" ||
+        !/^\d+\.\d+\.\d+$/.test(value.version) ||
+        typeof value.seed !== "string" ||
+        value.seed.trim() === "" ||
+        value.seed.length > 128 ||
+        /[\r\n\t]/.test(value.seed) ||
+        sanitizeSecretString(value.seed) !== value.seed) {
         throw new EvalError("syntheticWorld.world must reference a safe world id, semantic version and non-secret seed.");
     }
 }
@@ -217,7 +363,10 @@ function normalizeTask(value) {
     assertKeys(value, ["description", "command"], "task");
     if (typeof value.description !== "string")
         throw new EvalError("task.description must be a string.");
-    if (!Array.isArray(value.command) || value.command.length === 0 || value.command.length > 64 || !value.command.every((entry) => typeof entry === "string" && entry.trim() !== ""))
+    if (!Array.isArray(value.command) ||
+        value.command.length === 0 ||
+        value.command.length > 64 ||
+        !value.command.every((entry) => typeof entry === "string" && entry.trim() !== ""))
         throw new EvalError("task.command must be a non-empty string array.");
 }
 function normalizeInjectedFailures(values) {
@@ -229,16 +378,25 @@ function normalizeInjectedFailures(values) {
         assertKeys(value, ["id", "type", "provider", "statusCode", "retryAfterMs"], "injected failure");
         if (!IDENTIFIER.test(value.id) || !IDENTIFIER.test(value.type))
             throw new EvalError("injected failure id/type is invalid.");
-        if (value.provider !== undefined && (typeof value.provider !== "string" || !IDENTIFIER.test(value.provider)))
+        if (value.provider !== undefined &&
+            (typeof value.provider !== "string" || !IDENTIFIER.test(value.provider)))
             throw new EvalError("injected failure provider is invalid.");
-        if (value.statusCode !== undefined && (!Number.isInteger(value.statusCode) || value.statusCode < 400 || value.statusCode > 599))
+        if (value.statusCode !== undefined &&
+            (!Number.isInteger(value.statusCode) ||
+                value.statusCode < 400 ||
+                value.statusCode > 599))
             throw new EvalError("injected failure statusCode must be an error status.");
-        if (value.retryAfterMs !== undefined && (!Number.isInteger(value.retryAfterMs) || value.retryAfterMs < 0 || value.retryAfterMs > 300_000))
+        if (value.retryAfterMs !== undefined &&
+            (!Number.isInteger(value.retryAfterMs) ||
+                value.retryAfterMs < 0 ||
+                value.retryAfterMs > 300_000))
             throw new EvalError("injected failure retryAfterMs is invalid.");
     }
 }
 function normalizeExpectations(values) {
-    if (!Array.isArray(values) || values.length === 0 || values.length > MAX_ITEMS)
+    if (!Array.isArray(values) ||
+        values.length === 0 ||
+        values.length > MAX_ITEMS)
         throw new EvalError("expectations must be a non-empty bounded array.");
     const ids = new Set();
     for (const value of values) {
@@ -248,11 +406,25 @@ function normalizeExpectations(values) {
         if (!IDENTIFIER.test(value.id) || ids.has(value.id))
             throw new EvalError("expectation id must be unique and stable.");
         ids.add(value.id);
-        if (!["run-finished", "run-exit-code", "scenario-completed", "provider-covered", "retry-observed", "no-provider-failures", "no-secrets", "no-production-egress", "evidence-passed"].includes(value.type))
+        if (![
+            "run-finished",
+            "run-exit-code",
+            "scenario-completed",
+            "provider-covered",
+            "retry-observed",
+            "no-provider-failures",
+            "no-secrets",
+            "no-production-egress",
+            "evidence-passed",
+        ].includes(value.type))
             throw new EvalError(`Unsupported expectation type: ${String(value.type)}`);
-        if ((value.type === "run-exit-code" && !Number.isInteger(value.value)) || ((value.type === "scenario-completed" || value.type === "provider-covered") && (typeof value.value !== "string" || !IDENTIFIER.test(value.value))))
+        if ((value.type === "run-exit-code" && !Number.isInteger(value.value)) ||
+            ((value.type === "scenario-completed" ||
+                value.type === "provider-covered") &&
+                (typeof value.value !== "string" || !IDENTIFIER.test(value.value))))
             throw new EvalError(`Expectation ${value.id} has an invalid value.`);
-        if (!["run-exit-code", "scenario-completed", "provider-covered"].includes(value.type) && value.value !== undefined)
+        if (!["run-exit-code", "scenario-completed", "provider-covered"].includes(value.type) &&
+            value.value !== undefined)
             throw new EvalError(`Expectation ${value.id} does not accept a value.`);
     }
 }
@@ -265,9 +437,15 @@ function normalizeForbidden(values) {
         assertKeys(value, ["id", "type", "value"], "forbidden action");
         if (!IDENTIFIER.test(value.id))
             throw new EvalError("forbidden action id is invalid.");
-        if (!["production-egress", "secret-leak", "provider-failure", "missing-scenario"].includes(value.type))
+        if (![
+            "production-egress",
+            "secret-leak",
+            "provider-failure",
+            "missing-scenario",
+        ].includes(value.type))
             throw new EvalError(`Unsupported forbidden action type: ${String(value.type)}`);
-        if (value.type === "missing-scenario" && (typeof value.value !== "string" || !IDENTIFIER.test(value.value)))
+        if (value.type === "missing-scenario" &&
+            (typeof value.value !== "string" || !IDENTIFIER.test(value.value)))
             throw new EvalError("missing-scenario forbidden actions require a scenario identifier.");
         if (value.type !== "missing-scenario" && value.value !== undefined)
             throw new EvalError(`${value.type} forbidden actions do not accept a value.`);
@@ -277,18 +455,26 @@ function normalizeLimits(value) {
     if (!isPlainObject(value))
         throw new EvalError("limits must be an object.");
     assertKeys(value, ["timeoutMs", "maxOutputBytes"], "limits");
-    if (!Number.isInteger(value.timeoutMs) || value.timeoutMs < 100 || value.timeoutMs > 300_000)
+    if (!Number.isInteger(value.timeoutMs) ||
+        value.timeoutMs < 100 ||
+        value.timeoutMs > 300_000)
         throw new EvalError("limits.timeoutMs must be between 100 and 300000.");
-    if (!Number.isInteger(value.maxOutputBytes) || value.maxOutputBytes < 0 || value.maxOutputBytes > 10 * 1024 * 1024)
+    if (!Number.isInteger(value.maxOutputBytes) ||
+        value.maxOutputBytes < 0 ||
+        value.maxOutputBytes > 10 * 1024 * 1024)
         throw new EvalError("limits.maxOutputBytes must be bounded.");
 }
 function normalizeRubric(value, expectations) {
     if (!isPlainObject(value))
         throw new EvalError("rubric must be an object.");
     assertKeys(value, ["maxScore", "components"], "rubric");
-    if (!Number.isInteger(value.maxScore) || value.maxScore < 1 || value.maxScore > 1000)
+    if (!Number.isInteger(value.maxScore) ||
+        value.maxScore < 1 ||
+        value.maxScore > 1000)
         throw new EvalError("rubric.maxScore must be a positive bounded integer.");
-    if (!Array.isArray(value.components) || value.components.length === 0 || value.components.length > MAX_ITEMS)
+    if (!Array.isArray(value.components) ||
+        value.components.length === 0 ||
+        value.components.length > MAX_ITEMS)
         throw new EvalError("rubric.components must be a non-empty bounded array.");
     const expectationIds = new Set(expectations.map((expectation) => expectation.id));
     const componentIds = new Set();
@@ -298,9 +484,14 @@ function normalizeRubric(value, expectations) {
         if (!isPlainObject(component))
             throw new EvalError("rubric component must be an object.");
         assertKeys(component, ["id", "expectationId", "points", "reason"], "rubric component");
-        if (!IDENTIFIER.test(component.id) || componentIds.has(component.id) || !expectationIds.has(component.expectationId) || referencedExpectations.has(component.expectationId))
+        if (!IDENTIFIER.test(component.id) ||
+            componentIds.has(component.id) ||
+            !expectationIds.has(component.expectationId) ||
+            referencedExpectations.has(component.expectationId))
             throw new EvalError("rubric component id or expectation reference is duplicated or unknown.");
-        if (!Number.isInteger(component.points) || component.points < 0 || component.points > value.maxScore)
+        if (!Number.isInteger(component.points) ||
+            component.points < 0 ||
+            component.points > value.maxScore)
             throw new EvalError("rubric component points are invalid.");
         if (typeof component.reason !== "string" || component.reason.trim() === "")
             throw new EvalError("rubric component reason is required.");
@@ -315,11 +506,18 @@ function hasObservedRetry(evidence) {
     return evidence.egress.allowedAttempts.some((attempt, index, attempts) => {
         if (attempt.statusCode !== 429 && attempt.statusCode < 500)
             return false;
-        return attempts.slice(index + 1).some((later) => later.provider === attempt.provider && later.method === attempt.method && later.path === attempt.path);
+        return attempts
+            .slice(index + 1)
+            .some((later) => later.provider === attempt.provider &&
+            later.method === attempt.method &&
+            later.path === attempt.path);
     });
 }
 function hasEnforcedCompletedRun(evidence) {
-    return evidence.run.status === "finished" && evidence.enforcement.mode === "linux-network-namespace" && evidence.enforcement.isolated && !evidence.enforcement.degraded;
+    return (evidence.run.status === "finished" &&
+        evidence.enforcement.mode === "linux-network-namespace" &&
+        evidence.enforcement.isolated &&
+        !evidence.enforcement.degraded);
 }
 function template(id, title, expectations, forbidden, failures, scenarios) {
     return {
@@ -328,13 +526,24 @@ function template(id, title, expectations, forbidden, failures, scenarios) {
         id,
         title,
         syntheticWorld: { providers: ["stripe"], scenarios },
-        task: { description: `Run an agent workflow for ${title}.`, command: ["node", "agent-workflow.mjs"] },
+        task: {
+            description: `Run an agent workflow for ${title}.`,
+            command: ["node", "agent-workflow.mjs"],
+        },
         injectedFailures: failures,
         expectations,
         forbidden,
         limits: { timeoutMs: 60_000, maxOutputBytes: 512 * 1024 },
-        rubric: { maxScore: 100, components: expectations.map((expectation) => ({ id: expectation.id, expectationId: expectation.id, points: expectation.points ?? 0, reason: `${expectation.type} satisfied.` })) },
-        judge: { llmAsJudge: false }
+        rubric: {
+            maxScore: 100,
+            components: expectations.map((expectation) => ({
+                id: expectation.id,
+                expectationId: expectation.id,
+                points: expectation.points ?? 0,
+                reason: `${expectation.type} satisfied.`,
+            })),
+        },
+        judge: { llmAsJudge: false },
     };
 }
 function readBuiltinTemplate(name) {
@@ -344,7 +553,9 @@ function readBuiltinTemplate(name) {
     return template;
 }
 async function writeEvalReport(report, projectRoot, outPath) {
-    const target = outPath === undefined ? join(getDataPaths().reports, `${report.eval.id}.eval.json`) : await resolveOutputPath(outPath, projectRoot);
+    const target = outPath === undefined
+        ? join(getDataPaths().reports, `${report.eval.id}.eval.json`)
+        : await resolveOutputPath(outPath, projectRoot);
     await ensurePrivateDirectory(dirname(target));
     await atomicWriteJson(target, report);
     const source = await readFile(target, "utf8");
@@ -355,13 +566,15 @@ async function writeEvalReport(report, projectRoot, outPath) {
     return target;
 }
 async function resolveOutputPath(outPath, projectRoot) {
-    const target = isAbsolute(outPath) ? resolve(outPath) : resolve(projectRoot, outPath);
+    const target = isAbsolute(outPath)
+        ? resolve(outPath)
+        : resolve(projectRoot, outPath);
     assertPathInsideAllowedRoots(projectRoot, target);
     await mkdir(dirname(target), { recursive: true, mode: 0o700 });
     const parent = await lstat(dirname(target));
     if (!parent.isDirectory() || parent.isSymbolicLink())
         throw new EvalError("Eval output parent must be a real directory, not a symlink.");
-    if (!await isRealPathInsideAllowedRoots(dirname(target), projectRoot))
+    if (!(await isRealPathInsideAllowedRoots(dirname(target), projectRoot)))
         throw new EvalError("Eval output parent resolves outside the project root or GHOSTAPI_DATA_DIR through a symlink.");
     const existing = await lstat(target).catch((error) => isErrorCode(error, "ENOENT") ? null : Promise.reject(error));
     if (existing?.isSymbolicLink())
@@ -374,7 +587,7 @@ async function resolveExistingPath(path, projectRoot) {
     const info = await lstat(target);
     if (!info.isFile() || info.isSymbolicLink())
         throw new EvalError("Eval input path must be a regular non-symlink file.");
-    if (!await isRealPathInsideAllowedRoots(target, projectRoot))
+    if (!(await isRealPathInsideAllowedRoots(target, projectRoot)))
         throw new EvalError("Eval input resolves outside the project root or GHOSTAPI_DATA_DIR through a symlink.");
     return target;
 }
@@ -398,16 +611,21 @@ function assertPathInsideAllowedRoots(projectRoot, target) {
 }
 function isInside(root, target) {
     const relativePath = relative(resolve(root), target);
-    return relativePath !== ".." && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
+    return (relativePath !== ".." &&
+        !relativePath.startsWith(`..${sep}`) &&
+        !isAbsolute(relativePath));
 }
 async function isRealPathInsideAllowedRoots(target, projectRoot) {
     const realTarget = await realpath(target);
     const realProjectRoot = await realpath(projectRoot);
     const dataRoot = await realpath(getDataPaths().root).catch(() => null);
-    return isInside(realProjectRoot, realTarget) || (dataRoot !== null && isInside(dataRoot, realTarget));
+    return (isInside(realProjectRoot, realTarget) ||
+        (dataRoot !== null && isInside(dataRoot, realTarget)));
 }
 function readIdentifierArray(value, label) {
-    if (!Array.isArray(value) || value.length > MAX_ITEMS || !value.every((entry) => typeof entry === "string" && IDENTIFIER.test(entry)))
+    if (!Array.isArray(value) ||
+        value.length > MAX_ITEMS ||
+        !value.every((entry) => typeof entry === "string" && IDENTIFIER.test(entry)))
         throw new EvalError(`${label} must be a bounded array of identifiers.`);
 }
 function assertKeys(value, allowed, label) {
@@ -441,7 +659,9 @@ function hashLogicalReport(report) {
     return hashStable(logical);
 }
 function hashStable(value) {
-    return createHash("sha256").update(stableStringify(value), "utf8").digest("hex");
+    return createHash("sha256")
+        .update(stableStringify(value), "utf8")
+        .digest("hex");
 }
 function stableStringify(value) {
     if (value === undefined)
@@ -450,15 +670,21 @@ function stableStringify(value) {
         return JSON.stringify(value);
     if (Array.isArray(value))
         return `[${value.map(stableStringify).join(",")}]`;
-    const entries = Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([left], [right]) => left.localeCompare(right));
+    const entries = Object.entries(value)
+        .filter(([, entry]) => entry !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right));
     return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(",")}}`;
 }
 function sanitizedText(value) {
     const sanitized = sanitizeSecretString(value).replace(/[\r\n\t]/g, " ");
-    return sanitized.length > 2_000 ? `${sanitized.slice(0, 2_000)}[truncated]` : sanitized;
+    return sanitized.length > 2_000
+        ? `${sanitized.slice(0, 2_000)}[truncated]`
+        : sanitized;
 }
 function escapeTerminal(value) {
-    return sanitizedText(value).replace(/[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g, "").replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+    return sanitizedText(value)
+        .replace(/[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g, "")
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
 }
 function isErrorCode(error, code) {
     return error instanceof Error && "code" in error && error.code === code;