@attest-ai/core 0.9.0 → 1.0.0-rc.1

package/dist/esm/index.js

@@ -6,6 +6,15 @@ var STEP_AGENT_CALL = "agent_call";
 var STATUS_PASS = "pass";
 var STATUS_SOFT_FAIL = "soft_fail";
 var STATUS_HARD_FAIL = "hard_fail";
+var STATUS_NOT_EVALUATED = "not_evaluated";
+var REASON_PROVIDER_UNAVAILABLE = "provider_unavailable";
+var REASON_PROVIDER_NOT_CONFIGURED = "provider_not_configured";
+var REASON_SIMULATION = "simulation";
+var REASON_MISSING_EVIDENCE = "missing_evidence";
+var REASON_SHORT_CIRCUITED = "short_circuited";
+var OUTCOME_PASS = "pass";
+var OUTCOME_FAIL = "fail";
+var OUTCOME_SKIP = "skip";
 var TYPE_SCHEMA = "schema";
 var TYPE_CONSTRAINT = "constraint";
 var TYPE_TRACE = "trace";
@@ -31,6 +40,13 @@ function assertionId(id) {
 function agentId(id) {
   return id;
 }
+var FailureClass = {
+  BrokenCode: "broken_code",
+  FlakyJudge: "flaky_judge",
+  BadRubric: "bad_rubric",
+  MissingTraceData: "missing_trace_data",
+  StochasticVariance: "stochastic_variance"
+};
 function layerForType(assertionType) {
   switch (assertionType) {
     case "schema":
@@ -192,15 +208,14 @@ function extractId(response) {
 }
 
 // src/version.ts
-var VERSION = "0.9.0";
-var ENGINE_VERSION = "0.9.0";
+var VERSION = "1.0.0-rc.1";
+var ENGINE_VERSION = "1.0.0-rc.1";
 
 // src/engine-manager.ts
-import { spawn, execSync } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import { createInterface } from "readline";
-import { existsSync as existsSync2, accessSync, constants as fsConstants } from "fs";
-import { resolve, join as join2, dirname } from "path";
-import { fileURLToPath } from "url";
+import { existsSync, accessSync, statSync as statSync2, constants as fsConstants } from "fs";
+import { delimiter, join as join2 } from "path";
 
 // src/engine-downloader.ts
 import * as https from "https";
@@ -212,10 +227,8 @@ import * as crypto from "crypto";
 var RELEASE_BASE = `https://github.com/attest-framework/attest/releases/download/v${ENGINE_VERSION}`;
 var CHECKSUMS_URL = `${RELEASE_BASE}/checksums-sha256.txt`;
 var MAX_REDIRECTS = 5;
-function attestBinDir() {
-  const dir = path.join(os.homedir(), ".attest", "bin");
-  fs.mkdirSync(dir, { recursive: true });
-  return dir;
+function versionedBinDir() {
+  return path.join(os.homedir(), ".attest", "bin", ENGINE_VERSION);
 }
 function platformKey() {
   const platform2 = os.platform();
@@ -243,20 +256,8 @@ function binaryFilename() {
   return os.platform() === "win32" ? "attest-engine.exe" : "attest-engine";
 }
 function cachedEnginePath() {
-  const dir = path.join(os.homedir(), ".attest", "bin");
-  const binPath = path.join(dir, binaryFilename());
-  const versionFile = path.join(dir, ".engine-version");
-  if (!fs.existsSync(binPath)) {
-    return null;
-  }
-  if (!fs.existsSync(versionFile)) {
-    return null;
-  }
-  const cachedVersion = fs.readFileSync(versionFile, "utf-8").trim();
-  if (cachedVersion !== ENGINE_VERSION) {
-    return null;
-  }
-  return binPath;
+  const binPath = path.join(versionedBinDir(), binaryFilename());
+  return fs.statSync(binPath, { throwIfNoEntry: false })?.isFile() ? binPath : null;
 }
 function parseChecksums(text) {
   const checksums = /* @__PURE__ */ new Map();
@@ -276,7 +277,7 @@ function httpsGet(url, redirectCount = 0) {
       new Error(`Too many redirects (>${MAX_REDIRECTS}) following ${url}`)
     );
   }
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     const client = url.startsWith("https:") ? https : http;
     client.get(url, (res) => {
       const status = res.statusCode ?? 0;
@@ -287,7 +288,7 @@ function httpsGet(url, redirectCount = 0) {
           return;
         }
         res.resume();
-        resolve2(httpsGet(location, redirectCount + 1));
+        resolve(httpsGet(location, redirectCount + 1));
         return;
       }
       if (status < 200 || status >= 300) {
@@ -297,14 +298,14 @@ function httpsGet(url, redirectCount = 0) {
       }
       const chunks = [];
       res.on("data", (chunk) => chunks.push(chunk));
-      res.on("end", () => resolve2(Buffer.concat(chunks)));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
       res.on("error", reject);
     }).on("error", reject);
   });
 }
 async function downloadEngine() {
   const key = platformKey();
-  const filename = `attest-engine-${key}`;
+  const filename = `attest-engine-${key}${os.platform() === "win32" ? ".exe" : ""}`;
   const binaryUrl = `${RELEASE_BASE}/${filename}`;
   process.stderr.write(`[attest] Downloading engine v${ENGINE_VERSION} for ${key}...
 `);
@@ -324,19 +325,24 @@ async function downloadEngine() {
   const actualHash = crypto.createHash("sha256").update(data).digest("hex");
   if (actualHash !== expectedHash) {
     throw new Error(
-      `SHA256 mismatch for ${filename}. Expected: ${expectedHash}, got: ${actualHash}. The download may be corrupted. Delete ~/.attest/bin/ and retry.`
+      `SHA256 mismatch for ${filename}. Expected: ${expectedHash}, got: ${actualHash}. The download may be corrupted. Retry or download manually.`
     );
   }
   process.stderr.write(`[attest] Checksum verified.
 `);
-  const dir = attestBinDir();
-  const destFilename = binaryFilename();
-  const destPath = path.join(dir, destFilename);
-  const tmpPath = path.join(dir, `.${destFilename}.tmp.${process.pid}`);
-  fs.writeFileSync(tmpPath, data);
-  fs.chmodSync(tmpPath, 493);
-  fs.renameSync(tmpPath, destPath);
-  fs.writeFileSync(path.join(dir, ".engine-version"), ENGINE_VERSION);
+  const dir = versionedBinDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const destPath = path.join(dir, binaryFilename());
+  const suffix = `${String(process.pid)}.${crypto.randomBytes(8).toString("hex")}`;
+  const tmpPath = path.join(dir, `.${binaryFilename()}.tmp.${suffix}`);
+  try {
+    fs.writeFileSync(tmpPath, data, { flag: "wx", mode: 493 });
+    fs.chmodSync(tmpPath, 493);
+    fs.renameSync(tmpPath, destPath);
+  } catch (err) {
+    if (err.code !== "EEXIST") fs.rmSync(tmpPath, { force: true });
+    throw err;
+  }
   process.stderr.write(`[attest] Engine installed at ${destPath}
 `);
   return destPath;
@@ -344,45 +350,92 @@ async function downloadEngine() {
 
 // src/engine-manager.ts
 var ENGINE_BINARY_NAME = "attest-engine";
-async function findEngineBinary() {
-  const envPath = process.env["ATTEST_ENGINE_PATH"];
-  if (envPath) {
-    if (!existsSync2(envPath)) {
-      throw new Error(
-        `ATTEST_ENGINE_PATH is set to '${envPath}' but the file does not exist.`
-      );
-    }
-    return envPath;
-  }
-  try {
-    const cmd = process.platform === "win32" ? "where" : "which";
-    const found = execSync(`${cmd} ${ENGINE_BINARY_NAME}`, { encoding: "utf-8" }).trim();
-    if (found) return found;
-  } catch {
+var VERSION_PROBE_TIMEOUT_MS = 1e4;
+var EngineVersionMismatchError = class extends Error {
+  enginePath;
+  source;
+  found;
+  required;
+  constructor(enginePath, source, found, required) {
+    const reported = found === null ? "reports no version" : `reports version ${found}`;
+    super(
+      `attest-engine at ${enginePath} (from ${source}) ${reported}; this SDK requires attest-engine ${required}. Point ATTEST_ENGINE_PATH at a matching engine, or remove the mismatched one from PATH so the SDK can download ${required} into ~/.attest/bin/${required}/.`
+    );
+    this.name = "EngineVersionMismatchError";
+    this.enginePath = enginePath;
+    this.source = source;
+    this.found = found;
+    this.required = required;
   }
-  const cached = cachedEnginePath();
-  if (cached) return cached;
-  const candidates = [
-    join2(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "..", "..", "bin", ENGINE_BINARY_NAME),
-    join2(process.cwd(), "bin", ENGINE_BINARY_NAME)
-  ];
-  for (const candidate of candidates) {
-    const resolved = resolve(candidate);
+};
+function engineVersion(enginePath) {
+  const proc = spawnSync(enginePath, ["version"], {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    timeout: VERSION_PROBE_TIMEOUT_MS
+  });
+  if (proc.error) throw proc.error;
+  const out = proc.stdout.trim();
+  const prefix = `${ENGINE_BINARY_NAME} `;
+  if (proc.status !== 0 || !out.startsWith(prefix)) return null;
+  return out.slice(prefix.length).trim();
+}
+function onPath() {
+  for (const dir of (process.env["PATH"] ?? "").split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join2(dir, binaryFilename());
     try {
-      accessSync(resolved, fsConstants.X_OK);
-      if (existsSync2(resolved)) return resolved;
+      accessSync(candidate, fsConstants.X_OK);
     } catch {
+      continue;
     }
+    if (statSync2(candidate).isFile()) return candidate;
+  }
+  return null;
+}
+function requireFile(enginePath, label) {
+  if (!existsSync(enginePath) || !statSync2(enginePath).isFile()) {
+    throw new Error(`${label}=${enginePath} does not exist or is not a file.`);
+  }
+}
+async function locateEngine(explicitPath, allowDownload) {
+  if (explicitPath) {
+    requireFile(explicitPath, "Engine path");
+    return [explicitPath, "explicit engine path"];
   }
-  const noDownload = process.env["ATTEST_ENGINE_NO_DOWNLOAD"];
+  const envPath = process.env["ATTEST_ENGINE_PATH"];
+  if (envPath) {
+    requireFile(envPath, "ATTEST_ENGINE_PATH");
+    return [envPath, "ATTEST_ENGINE_PATH"];
+  }
+  const found = onPath();
+  if (found) return [found, "PATH"];
+  const cached = cachedEnginePath();
+  if (cached) return [cached, "engine cache"];
+  if (!allowDownload) {
+    throw new Error(
+      `No '${ENGINE_BINARY_NAME}' ${ENGINE_VERSION} in ATTEST_ENGINE_PATH, PATH or ~/.attest/bin/${ENGINE_VERSION}/.`
+    );
+  }
+  const noDownload = process.env["ATTEST_ENGINE_NO_DOWNLOAD"]?.toLowerCase();
   if (noDownload === "1" || noDownload === "true" || noDownload === "yes") {
     throw new Error(
-      `Cannot find '${ENGINE_BINARY_NAME}' binary and auto-download is disabled (ATTEST_ENGINE_NO_DOWNLOAD is set). Install the engine manually:
-  1. Download from https://github.com/attest-framework/attest/releases
-  2. Place the binary on your PATH or set ATTEST_ENGINE_PATH`
+      `Cannot find '${ENGINE_BINARY_NAME}' ${ENGINE_VERSION} and ATTEST_ENGINE_NO_DOWNLOAD is set.
+Install options:
+  1. Build from source: make engine, then set ATTEST_ENGINE_PATH
+  2. Download release v${ENGINE_VERSION}: https://github.com/attest-framework/attest/releases
+  3. Allow auto-download by unsetting ATTEST_ENGINE_NO_DOWNLOAD`
     );
   }
-  return downloadEngine();
+  return [await downloadEngine(), "download"];
+}
+async function resolveEngine(explicitPath, options = {}) {
+  const [enginePath, source] = await locateEngine(explicitPath, options.allowDownload ?? true);
+  const found = engineVersion(enginePath);
+  if (found !== ENGINE_VERSION) {
+    throw new EngineVersionMismatchError(enginePath, source, found, ENGINE_VERSION);
+  }
+  return enginePath;
 }
 var EngineManager = class {
   enginePath;
@@ -397,28 +450,41 @@ var EngineManager = class {
     this.logLevel = options?.logLevel ?? "warn";
   }
   async start() {
-    if (!this.enginePath) {
-      this.enginePath = await findEngineBinary();
-    }
+    this.enginePath = await resolveEngine(this.enginePath || void 0);
     this.process = spawn(this.enginePath, [`--log-level=${this.logLevel}`], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.reader = createInterface({ input: this.process.stdout });
-    const result = await this.sendRequestInternal("initialize", {
+    try {
+      this.initResult = await this.initialize();
+    } catch (err) {
+      await this.stop();
+      throw err;
+    }
+    this.initialized = true;
+    return this.initResult;
+  }
+  /** Send initialize and check the engine's version and capabilities. */
+  async initialize() {
+    const init = await this.sendRequestInternal("initialize", {
       sdk_name: "attest-typescript",
       sdk_version: VERSION,
       protocol_version: 1,
       required_capabilities: ["layers_1_4"],
       preferred_encoding: "json"
     });
-    this.initResult = result;
-    if (!this.initResult.compatible) {
-      throw new Error(
-        `Engine incompatible. Missing capabilities: ${JSON.stringify(this.initResult.missing)}`
+    if (init.engine_version !== ENGINE_VERSION) {
+      throw new EngineVersionMismatchError(
+        this.enginePath,
+        "initialize",
+        init.engine_version,
+        ENGINE_VERSION
       );
     }
-    this.initialized = true;
-    return this.initResult;
+    if (!init.compatible) {
+      throw new Error(`Engine incompatible. Missing capabilities: ${JSON.stringify(init.missing)}`);
+    }
+    return init;
   }
   async stop() {
     if (this.process === null) return;
@@ -459,11 +525,11 @@ var EngineManager = class {
     }
     this.requestId += 1;
     const requestStr = encodeRequest(this.requestId, method, params);
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       const onLine = (line) => {
         try {
           const response = decodeResponse(line);
-          resolve2(extractResult(response));
+          resolve(extractResult(response));
         } catch (err) {
           reject(err);
         }
@@ -511,7 +577,11 @@ function config(options) {
   }
 }
 function isSimulationMode() {
-  return _simulationMode || process.env["ATTEST_SIMULATION"] === "1" || process.env["ATTEST_SIMULATION"] === "true" || process.env["ATTEST_SIMULATION"] === "yes";
+  return _simulationMode || simulationEnvEnabled();
+}
+function simulationEnvEnabled() {
+  const env = (process.env["ATTEST_SIMULATION"] ?? "").trim().toLowerCase();
+  return env === "1" || env === "true" || env === "yes";
 }
 function getSampleRate() {
   if (_sampleRate > 0) return _sampleRate;
@@ -532,24 +602,6 @@ function resetConfig() {
   _sampleRate = 0;
 }
 
-// src/simulation.ts
-function simulationEvaluateBatch(assertions) {
-  const results = assertions.map((assertion) => ({
-    assertion_id: assertion.assertion_id,
-    status: "pass",
-    score: 1,
-    explanation: `[simulation] assertion '${assertion.assertion_id}' passed (type: ${assertion.type})`,
-    cost: 0,
-    duration_ms: 0
-  }));
-  return {
-    results,
-    total_cost: 0,
-    total_duration_ms: 0,
-    simulated: true
-  };
-}
-
 // src/client.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_DIAGNOSTIC_BUFFER = 32;
@@ -774,12 +826,12 @@ var AttestClient = class {
       throw new Error("Engine process not started.");
     }
     let capturedReqId;
-    const requestPromise = new Promise((resolve2, reject) => {
+    const requestPromise = new Promise((resolve, reject) => {
       this.writeChain = this.writeChain.then(() => {
         this.requestId += 1;
         const reqId = this.requestId;
         capturedReqId = reqId;
-        this.pending.set(reqId, { resolve: resolve2, reject });
+        this.pending.set(reqId, { resolve, reject });
         const requestStr = encodeRequest(reqId, method, params);
         cp.stdin.write(requestStr, (err) => {
           if (err) {
@@ -799,7 +851,7 @@ var AttestClient = class {
   }
   async evaluateBatch(trace, assertions, options) {
     if (isSimulationMode()) {
-      return simulationEvaluateBatch(assertions);
+      requireSimulationCapability(this.engine["initResult"]);
     }
     const params = {
       trace,
@@ -838,10 +890,10 @@ var AttestClient = class {
     if (isSimulationMode()) {
       return {
         assertion_id: assertionId2,
-        mean: 1,
+        mean: 0,
         stddev: 0,
         count: 0,
-        latest_score: 1,
+        latest_score: 0,
         deviation: 0,
         status: "no_data"
       };
@@ -879,6 +931,16 @@ function classifyDecodeError(message) {
   if (message.startsWith("empty response line")) return "malformed_json";
   return "malformed_json";
 }
+function requireSimulationCapability(init) {
+  if (init === null || init === void 0) {
+    throw new Error("simulation mode: the engine has not been initialized");
+  }
+  if (!(init.capabilities ?? []).includes("simulation_mode")) {
+    throw new Error(
+      `simulation mode is on but attest-engine ${init.engine_version} was not started in simulation mode (capability 'simulation_mode' missing), so it would call real providers. Set ATTEST_SIMULATION=1 before the engine starts (the Vitest fixtures do this for you) and use attest-engine 1.0 or later.`
+    );
+  }
+}
 
 // src/trace.ts
 import { randomUUID } from "crypto";
@@ -969,6 +1031,20 @@ var TraceBuilder = class {
 };
 
 // src/result.ts
+var KNOWN_STATUSES = /* @__PURE__ */ new Set([
+  STATUS_PASS,
+  STATUS_SOFT_FAIL,
+  STATUS_HARD_FAIL,
+  STATUS_NOT_EVALUATED
+]);
+function normalizeAssertionResult(r) {
+  if (KNOWN_STATUSES.has(r.status)) return r;
+  return {
+    ...r,
+    status: STATUS_NOT_EVALUATED,
+    explanation: `[unknown status '${r.status}'] ${r.explanation}`
+  };
+}
 var AgentResult = class {
   trace;
   assertionResults;
@@ -976,15 +1052,31 @@ var AgentResult = class {
   totalDurationMs;
   constructor(trace, assertionResults = [], totalCost = 0, totalDurationMs = 0) {
     this.trace = trace;
-    this.assertionResults = assertionResults;
+    this.assertionResults = assertionResults.map(normalizeAssertionResult);
     this.totalCost = totalCost;
     this.totalDurationMs = totalDurationMs;
   }
+  /** True if every assertion has status "pass". */
   get passed() {
     return this.assertionResults.every((r) => r.status === STATUS_PASS);
   }
+  /**
+   * Test outcome after the whole batch. Any hard_fail fails; otherwise any
+   * not_evaluated skips (fails when `strict`); otherwise pass, including
+   * when only soft_fail rows are present (see `softFailures`).
+   */
+  outcome(options) {
+    if (this.hardFailures.length > 0) return OUTCOME_FAIL;
+    if (this.notEvaluated.length > 0) {
+      return options?.strict === true ? OUTCOME_FAIL : OUTCOME_SKIP;
+    }
+    return OUTCOME_PASS;
+  }
+  /** Failed assertions: hard_fail and soft_fail only. */
   get failedAssertions() {
-    return this.assertionResults.filter((r) => r.status !== STATUS_PASS);
+    return this.assertionResults.filter(
+      (r) => r.status === STATUS_HARD_FAIL || r.status === STATUS_SOFT_FAIL
+    );
   }
   get hardFailures() {
     return this.assertionResults.filter((r) => r.status === STATUS_HARD_FAIL);
@@ -992,11 +1084,40 @@ var AgentResult = class {
   get softFailures() {
     return this.assertionResults.filter((r) => r.status === STATUS_SOFT_FAIL);
   }
+  /** Assertions the engine did not evaluate; each carries a `reason`. */
+  get notEvaluated() {
+    return this.assertionResults.filter((r) => r.status === STATUS_NOT_EVALUATED);
+  }
+  /** Count of not_evaluated assertions per reason, in first-seen order. */
+  get notEvaluatedReasons() {
+    const counts = {};
+    for (const r of this.notEvaluated) {
+      const key = r.reason || "unknown";
+      counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return counts;
+  }
+  /**
+   * Passed / evaluated assertions; null when nothing was evaluated.
+   * not_evaluated rows are excluded from the denominator.
+   */
+  get passRate() {
+    const evaluated = this.assertionResults.length - this.notEvaluated.length;
+    return evaluated === 0 ? null : this.passCount / evaluated;
+  }
   get passCount() {
     return this.assertionResults.filter((r) => r.status === STATUS_PASS).length;
   }
+  /** Number of failed assertions (hard_fail + soft_fail). */
   get failCount() {
-    return this.assertionResults.length - this.passCount;
+    return this.failedAssertions.length;
+  }
+  /** "not evaluated: <reason>[, <reason> ×n ...]" for skipped tests. */
+  skipReason() {
+    const parts = Object.entries(this.notEvaluatedReasons).map(
+      ([reason, n]) => n === 1 ? reason : `${reason} \xD7${n}`
+    );
+    return `not evaluated: ${parts.join(", ")}`;
   }
 };
 
@@ -1036,6 +1157,9 @@ function statusGlyph(status, color) {
   } else if (status === STATUS_HARD_FAIL) {
     glyph = "FAIL";
     c = ANSI_RED;
+  } else if (status === STATUS_NOT_EVALUATED) {
+    glyph = "N/E";
+    c = ANSI_DIM;
   } else {
     glyph = status.toUpperCase() || "????";
     c = ANSI_DIM;
@@ -1063,10 +1187,15 @@ function renderAssertionFailure(result, options = {}) {
   lines.push(
     `  ${statusGlyph(result.status, color)} ${bold(result.assertion_id, color)} ${dim(`\u2014 ${label}`, color)}`
   );
+  if (result.reason) {
+    lines.push(`      reason:     not evaluated: ${result.reason}`);
+  }
   if (result.trace_node_path) {
     lines.push(`      trace path: ${result.trace_node_path}`);
   }
-  lines.push(`      score:      ${result.score.toFixed(3)}`);
+  if (result.status !== STATUS_NOT_EVALUATED) {
+    lines.push(`      score:      ${result.score.toFixed(3)}`);
+  }
   if (result.expected) {
     lines.push(`      expected:   ${truncate(result.expected)}`);
   }
@@ -1079,6 +1208,9 @@ function renderAssertionFailure(result, options = {}) {
   if (result.threshold_source && result.threshold_source !== "static") {
     lines.push(`      threshold:  ${result.threshold_source}`);
   }
+  if (result.failure_class) {
+    lines.push(`      class:      ${result.failure_class}`);
+  }
   if (result.judge_metadata) {
     appendJudgeMetadata(lines, result.judge_metadata);
   }
@@ -1141,6 +1273,7 @@ function renderSummary(result, options = {}) {
     `${statusGlyph(STATUS_PASS, color)} ${passN}`,
     `${statusGlyph(STATUS_SOFT_FAIL, color)} ${soft}`,
     `${statusGlyph(STATUS_HARD_FAIL, color)} ${hard}`,
+    `${statusGlyph(STATUS_NOT_EVALUATED, color)} ${result.notEvaluated.length}`,
     `cost $${result.totalCost.toFixed(6)}`,
     `dur ${result.totalDurationMs}ms`
   ];
@@ -1149,23 +1282,27 @@ function renderSummary(result, options = {}) {
 function renderDiagnostics(result, options = {}) {
   const color = options.color ?? false;
   const includePassing = options.includePassing ?? false;
-  const rows = includePassing ? result.assertionResults : result.failedAssertions;
+  const rows = includePassing ? result.assertionResults : result.assertionResults.filter((r) => r.status !== STATUS_PASS);
   if (rows.length === 0) {
     return dim("  (no failures)\n", color);
   }
   const out = [""];
-  out.push(
-    bold(
-      `Attest diagnostic \u2014 ${rows.length} of ${result.assertionResults.length} assertions failed:`,
-      color
-    )
-  );
+  out.push(bold(`Attest diagnostic \u2014 ${headerCounts(result)}:`, color));
   for (const r of rows) {
     out.push(renderAssertionFailure(r, options));
   }
   out.push(dim(`  Summary: ${renderSummary(result, { color })}`, color));
   return out.join("\n");
 }
+function headerCounts(result) {
+  const total = result.assertionResults.length;
+  const notEvaluated = result.notEvaluated.length;
+  if (result.failCount === 0 && notEvaluated > 0) {
+    return `${notEvaluated} of ${total} assertions not evaluated`;
+  }
+  const text = `${result.failCount} of ${total} assertions failed`;
+  return notEvaluated > 0 ? `${text}, ${notEvaluated} not evaluated` : text;
+}
 
 // src/trace-tree.ts
 var TraceTree = class {
@@ -3021,17 +3158,27 @@ export {
   EngineTimeoutError,
   ExpectChain,
   FRIENDLY_USER,
+  FailureClass,
   GeminiAdapter,
   LangChainAdapter,
   ManualAdapter,
   OTelAdapter,
+  OUTCOME_FAIL,
+  OUTCOME_PASS,
+  OUTCOME_SKIP,
   OllamaAdapter,
   OpenAIAdapter,
   PluginRegistry,
   ProtocolDesyncError,
   ProtocolDiagnosticBuffer,
   ProtocolError,
+  REASON_MISSING_EVIDENCE,
+  REASON_PROVIDER_NOT_CONFIGURED,
+  REASON_PROVIDER_UNAVAILABLE,
+  REASON_SHORT_CIRCUITED,
+  REASON_SIMULATION,
   STATUS_HARD_FAIL,
+  STATUS_NOT_EVALUATED,
   STATUS_PASS,
   STATUS_SOFT_FAIL,
   STEP_AGENT_CALL,
@@ -3076,8 +3223,9 @@ export {
   renderAssertionFailure,
   renderDiagnostics,
   renderSummary,
+  requireSimulationCapability,
   resetConfig,
-  simulationEvaluateBatch,
+  simulationEnvEnabled,
   tier,
   traceId
 };