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

package/dist/esm/index.js

@@ -14,6 +14,8 @@ var REASON_MISSING_EVIDENCE = "missing_evidence";
 var REASON_SHORT_CIRCUITED = "short_circuited";
 var REASON_BUDGET_EXHAUSTED = "budget_exhausted";
 var REASON_JUDGE_ABSTAINED = "judge_abstained";
+var REASON_JUDGE_MALFORMED = "judge_malformed";
+var REASON_PROVIDER_AUTH = "provider_auth";
 var REASON_REPLAY_MISS = "replay_miss";
 var OUTCOME_PASS = "pass";
 var OUTCOME_FAIL = "fail";
@@ -49,7 +51,8 @@ var FailureClass = {
   FlakyJudge: "flaky_judge",
   BadRubric: "bad_rubric",
   MissingTraceData: "missing_trace_data",
-  StochasticVariance: "stochastic_variance"
+  StochasticVariance: "stochastic_variance",
+  SpecError: "spec_error"
 };
 function layerForType(assertionType) {
   switch (assertionType) {
@@ -219,506 +222,162 @@ function extractId(response) {
 }
 
 // src/version.ts
-var VERSION = "1.0.0";
-var ENGINE_VERSION = "1.0.0";
+var VERSION = "1.1.0-rc.1";
+var ENGINE_VERSION = "1.1.0-rc.1";
 
 // src/engine-manager.ts
 import { spawn, spawnSync } from "child_process";
 import { createInterface } from "readline";
-import { existsSync, accessSync, statSync as statSync2, constants as fsConstants } from "fs";
+import { existsSync as existsSync2, 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";
-import * as http from "http";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-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 versionedBinDir() {
-  return path.join(os.homedir(), ".attest", "bin", ENGINE_VERSION);
-}
-function platformKey() {
-  const platform2 = os.platform();
-  const arch2 = os.arch();
-  const mapping = {
-    darwin: { arm64: "darwin-arm64", x64: "darwin-amd64" },
-    linux: { arm64: "linux-arm64", x64: "linux-amd64" },
-    win32: { x64: "windows-amd64", arm64: "windows-arm64" }
-  };
-  const osMap = mapping[platform2];
-  if (!osMap) {
-    throw new Error(
-      `Unsupported platform: ${platform2}. Supported: darwin, linux, win32.`
-    );
+// src/config.ts
+var _simulationMode = false;
+var _sampleRate = 0;
+function config(options2) {
+  if (options2.simulation !== void 0) {
+    _simulationMode = options2.simulation;
   }
-  const key = osMap[arch2];
-  if (!key) {
-    throw new Error(
-      `Unsupported architecture '${arch2}' on platform '${platform2}'. Supported architectures: ${Object.keys(osMap).join(", ")}.`
-    );
+  if (options2.sampleRate !== void 0) {
+    if (options2.sampleRate < 0 || options2.sampleRate > 1) {
+      throw new RangeError(
+        `sampleRate must be between 0.0 and 1.0, got ${options2.sampleRate}`
+      );
+    }
+    _sampleRate = options2.sampleRate;
   }
-  return key;
 }
-function binaryFilename() {
-  return os.platform() === "win32" ? "attest-engine.exe" : "attest-engine";
+function isSimulationMode() {
+  return _simulationMode || simulationEnvEnabled();
 }
-function cachedEnginePath() {
-  const binPath = path.join(versionedBinDir(), binaryFilename());
-  return fs.statSync(binPath, { throwIfNoEntry: false })?.isFile() ? binPath : null;
+function simulationEnvEnabled() {
+  const env = (process.env["ATTEST_SIMULATION"] ?? "").trim().toLowerCase();
+  return env === "1" || env === "true" || env === "yes";
 }
-function parseChecksums(text) {
-  const checksums = /* @__PURE__ */ new Map();
-  for (const line of text.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    const match = trimmed.match(/^([a-f0-9]{64})\s+(.+)$/);
-    if (match) {
-      checksums.set(match[2], match[1]);
+function getSampleRate() {
+  if (_sampleRate > 0) return _sampleRate;
+  const env = process.env["ATTEST_SAMPLE_RATE"];
+  if (env !== void 0 && env !== "") {
+    const parsed = Number(env);
+    if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+      throw new RangeError(
+        `ATTEST_SAMPLE_RATE must be between 0.0 and 1.0, got '${env}'`
+      );
     }
+    return parsed;
   }
-  return checksums;
-}
-function httpsGet(url, redirectCount = 0) {
-  if (redirectCount > MAX_REDIRECTS) {
-    return Promise.reject(
-      new Error(`Too many redirects (>${MAX_REDIRECTS}) following ${url}`)
-    );
-  }
-  return new Promise((resolve5, reject) => {
-    const client = url.startsWith("https:") ? https : http;
-    client.get(url, (res) => {
-      const status = res.statusCode ?? 0;
-      if (status === 301 || status === 302) {
-        const location = res.headers.location;
-        if (!location) {
-          reject(new Error(`Redirect ${status} without Location header from ${url}`));
-          return;
-        }
-        res.resume();
-        resolve5(httpsGet(location, redirectCount + 1));
-        return;
-      }
-      if (status < 200 || status >= 300) {
-        res.resume();
-        reject(new Error(`HTTP ${status} fetching ${url}`));
-        return;
-      }
-      const chunks = [];
-      res.on("data", (chunk) => chunks.push(chunk));
-      res.on("end", () => resolve5(Buffer.concat(chunks)));
-      res.on("error", reject);
-    }).on("error", reject);
-  });
+  return 0;
 }
-async function downloadEngine() {
-  const key = platformKey();
-  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}...
-`);
-  process.stderr.write(`[attest] Fetching checksums...
-`);
-  const checksumsText = (await httpsGet(CHECKSUMS_URL)).toString("utf-8");
-  const checksums = parseChecksums(checksumsText);
-  const expectedHash = checksums.get(filename);
-  if (!expectedHash) {
-    throw new Error(
-      `No checksum found for '${filename}' in checksums-sha256.txt. Available files: ${[...checksums.keys()].join(", ")}`
-    );
-  }
-  process.stderr.write(`[attest] Downloading ${binaryUrl}...
-`);
-  const data = await httpsGet(binaryUrl);
-  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. Retry or download manually.`
-    );
-  }
-  process.stderr.write(`[attest] Checksum verified.
-`);
-  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;
+function resetConfig() {
+  _simulationMode = false;
+  _sampleRate = 0;
 }
 
-// src/engine-manager.ts
-var ENGINE_BINARY_NAME = "attest-engine";
-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;
+// src/usage.ts
+var INT_FIELDS = [
+  "model_calls",
+  "judge_calls",
+  "input_tokens",
+  "output_tokens",
+  "cached_tokens",
+  "unpriced_calls",
+  "budget_refused"
+];
+var USD_FIELDS = ["cost_usd", "retry_cost_usd"];
+function zeroUsage() {
+  return {
+    model_calls: 0,
+    judge_calls: 0,
+    input_tokens: 0,
+    output_tokens: 0,
+    cached_tokens: 0,
+    cost_usd: 0,
+    retry_cost_usd: 0,
+    unpriced_calls: 0,
+    budget_refused: 0
+  };
+}
+function addUsage(a, b) {
+  return {
+    model_calls: a.model_calls + b.model_calls,
+    judge_calls: a.judge_calls + b.judge_calls,
+    input_tokens: a.input_tokens + b.input_tokens,
+    output_tokens: a.output_tokens + b.output_tokens,
+    cached_tokens: a.cached_tokens + b.cached_tokens,
+    cost_usd: a.cost_usd + b.cost_usd,
+    retry_cost_usd: a.retry_cost_usd + b.retry_cost_usd,
+    unpriced_calls: a.unpriced_calls + b.unpriced_calls,
+    budget_refused: a.budget_refused + b.budget_refused
+  };
+}
+function sumUsage(usages) {
+  let total = zeroUsage();
+  for (const u of usages) total = addUsage(total, u);
+  return total;
+}
+function parseUsage(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new TypeError(`evaluate_batch result: usage must be an object, got ${JSON.stringify(raw)}`);
   }
-};
-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();
+  const obj = raw;
+  const field = (name, integer) => {
+    const v = obj[name];
+    if (typeof v !== "number" || !Number.isFinite(v) || v < 0 || integer && !Number.isInteger(v)) {
+      const kind = integer ? "a non-negative integer" : "a non-negative number";
+      throw new TypeError(`evaluate_batch result: usage.${name} must be ${kind}, got ${JSON.stringify(v)}`);
+    }
+    return v;
+  };
+  const ints = Object.fromEntries(INT_FIELDS.map((f) => [f, field(f, true)]));
+  const usd = Object.fromEntries(USD_FIELDS.map((f) => [f, field(f, false)]));
+  return { ...ints, ...usd };
 }
-function onPath() {
-  for (const dir of (process.env["PATH"] ?? "").split(delimiter)) {
-    if (!dir) continue;
-    const candidate = join2(dir, binaryFilename());
-    try {
-      accessSync(candidate, fsConstants.X_OK);
-    } catch {
-      continue;
+function formatUsage(u) {
+  let line = `${u.model_calls} model calls \xB7 ${u.input_tokens + u.output_tokens} tokens (${u.cached_tokens} cached) \xB7 $${u.cost_usd.toFixed(4)} \xB7 retry cost $${u.retry_cost_usd.toFixed(4)}`;
+  if (u.budget_refused > 0) line += ` \xB7 ${u.budget_refused} calls refused by budget`;
+  if (u.unpriced_calls > 0) line += ` \xB7 ${u.unpriced_calls} unpriced calls not in $`;
+  return line;
+}
+function usageSummaryLine(u) {
+  if (u.model_calls === 0 && u.budget_refused === 0) return void 0;
+  return `attest usage: ${formatUsage(u)}`;
+}
+
+// src/client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_DIAGNOSTIC_BUFFER = 32;
+var DEFAULT_DESYNC_THRESHOLD = 3;
+var DEFAULT_DESYNC_WINDOW_MS = 1e3;
+var MAX_TIMEOUT_ENV_SECONDS = 3600;
+function resolveTimeoutMs(override) {
+  if (override !== void 0) return override;
+  const env = process.env["ATTEST_ENGINE_TIMEOUT"];
+  if (env !== void 0 && env !== "") {
+    const parsed = Number(env);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      throw new Error(
+        `ATTEST_ENGINE_TIMEOUT must be a positive number of seconds, got: '${env}'`
+      );
     }
-    if (statSync2(candidate).isFile()) return candidate;
+    if (parsed > MAX_TIMEOUT_ENV_SECONDS) {
+      throw new Error(
+        `ATTEST_ENGINE_TIMEOUT is in seconds since 1.1.0; got '${env}', which exceeds ${MAX_TIMEOUT_ENV_SECONDS}. A millisecond value such as 30000 must now be 30.`
+      );
+    }
+    return parsed * 1e3;
   }
-  return null;
+  return DEFAULT_TIMEOUT_MS;
 }
-function requireFile(enginePath, label) {
-  if (!existsSync(enginePath) || !statSync2(enginePath).isFile()) {
-    throw new Error(`${label}=${enginePath} does not exist or is not a file.`);
-  }
+function debugProtocolEnabled() {
+  const flag = process.env["ATTEST_DEBUG_PROTOCOL"];
+  return flag === "1" || flag === "true" || flag === "yes";
 }
-async function locateEngine(explicitPath, allowDownload) {
-  if (explicitPath) {
-    requireFile(explicitPath, "Engine path");
-    return [explicitPath, "explicit engine path"];
-  }
-  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}' ${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 [await downloadEngine(), "download"];
-}
-async function resolveEngine(explicitPath, options2 = {}) {
-  const [enginePath, source] = await locateEngine(explicitPath, options2.allowDownload ?? true);
-  const found = engineVersion(enginePath);
-  if (found !== ENGINE_VERSION) {
-    throw new EngineVersionMismatchError(enginePath, source, found, ENGINE_VERSION);
-  }
-  return enginePath;
-}
-var EngineManager = class {
-  enginePath;
-  logLevel;
-  process = null;
-  reader = null;
-  initialized = false;
-  requestId = 0;
-  initResult = null;
-  constructor(options2) {
-    this.enginePath = options2?.enginePath ?? "";
-    this.logLevel = options2?.logLevel ?? "warn";
-  }
-  async start() {
-    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 });
-    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"
-    });
-    if (init.engine_version !== ENGINE_VERSION) {
-      throw new EngineVersionMismatchError(
-        this.enginePath,
-        "initialize",
-        init.engine_version,
-        ENGINE_VERSION
-      );
-    }
-    if (!init.compatible) {
-      throw new Error(`Engine incompatible. Missing capabilities: ${JSON.stringify(init.missing)}`);
-    }
-    return init;
-  }
-  async stop() {
-    if (this.process === null) return;
-    if (this.initialized) {
-      try {
-        await this.sendRequestInternal("shutdown", {});
-      } catch {
-      }
-    }
-    if (this.reader) {
-      this.reader.close();
-      this.reader = null;
-    }
-    if (this.process.exitCode === null) {
-      this.process.kill("SIGTERM");
-      await new Promise((res) => {
-        const timer = setTimeout(() => {
-          this.process?.kill("SIGKILL");
-        }, 5e3);
-        this.process.on("exit", () => {
-          clearTimeout(timer);
-          res();
-        });
-      });
-    }
-    this.initialized = false;
-    this.process = null;
-  }
-  async sendRequest(method, params) {
-    if (!this.initialized && method !== "initialize") {
-      throw new Error("Engine not initialized. Call start() first.");
-    }
-    return this.sendRequestInternal(method, params);
-  }
-  async sendRequestInternal(method, params) {
-    if (this.process === null || this.process.stdin === null || this.reader === null) {
-      throw new Error("Engine process not started.");
-    }
-    this.requestId += 1;
-    const requestStr = encodeRequest(this.requestId, method, params);
-    return new Promise((resolve5, reject) => {
-      const onLine = (line) => {
-        try {
-          const response = decodeResponse(line);
-          resolve5(extractResult(response));
-        } catch (err) {
-          reject(err);
-        }
-      };
-      this.reader.once("line", onLine);
-      const ok = this.process.stdin.write(requestStr, (err) => {
-        if (err) {
-          this.reader.removeListener("line", onLine);
-          reject(err);
-        }
-      });
-      if (!ok) {
-        this.process.stdin.once("drain", () => {
-        });
-      }
-    });
-  }
-  get isRunning() {
-    return this.process !== null && this.process.exitCode === null;
-  }
-  /** Expose process for AttestClient reader loop access */
-  get childProcess() {
-    return this.process;
-  }
-  /** Expose readline interface for AttestClient reader loop */
-  get readlineInterface() {
-    return this.reader;
-  }
-};
-
-// src/config.ts
-var _simulationMode = false;
-var _sampleRate = 0;
-function config(options2) {
-  if (options2.simulation !== void 0) {
-    _simulationMode = options2.simulation;
-  }
-  if (options2.sampleRate !== void 0) {
-    if (options2.sampleRate < 0 || options2.sampleRate > 1) {
-      throw new RangeError(
-        `sampleRate must be between 0.0 and 1.0, got ${options2.sampleRate}`
-      );
-    }
-    _sampleRate = options2.sampleRate;
-  }
-}
-function isSimulationMode() {
-  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;
-  const env = process.env["ATTEST_SAMPLE_RATE"];
-  if (env !== void 0 && env !== "") {
-    const parsed = Number(env);
-    if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
-      throw new RangeError(
-        `ATTEST_SAMPLE_RATE must be between 0.0 and 1.0, got '${env}'`
-      );
-    }
-    return parsed;
-  }
-  return 0;
-}
-function resetConfig() {
-  _simulationMode = false;
-  _sampleRate = 0;
-}
-
-// src/usage.ts
-var INT_FIELDS = [
-  "model_calls",
-  "judge_calls",
-  "input_tokens",
-  "output_tokens",
-  "cached_tokens",
-  "unpriced_calls",
-  "budget_refused"
-];
-var USD_FIELDS = ["cost_usd", "retry_cost_usd"];
-function zeroUsage() {
-  return {
-    model_calls: 0,
-    judge_calls: 0,
-    input_tokens: 0,
-    output_tokens: 0,
-    cached_tokens: 0,
-    cost_usd: 0,
-    retry_cost_usd: 0,
-    unpriced_calls: 0,
-    budget_refused: 0
-  };
-}
-function addUsage(a, b) {
-  return {
-    model_calls: a.model_calls + b.model_calls,
-    judge_calls: a.judge_calls + b.judge_calls,
-    input_tokens: a.input_tokens + b.input_tokens,
-    output_tokens: a.output_tokens + b.output_tokens,
-    cached_tokens: a.cached_tokens + b.cached_tokens,
-    cost_usd: a.cost_usd + b.cost_usd,
-    retry_cost_usd: a.retry_cost_usd + b.retry_cost_usd,
-    unpriced_calls: a.unpriced_calls + b.unpriced_calls,
-    budget_refused: a.budget_refused + b.budget_refused
-  };
-}
-function sumUsage(usages) {
-  let total = zeroUsage();
-  for (const u of usages) total = addUsage(total, u);
-  return total;
-}
-function parseUsage(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    throw new TypeError(`evaluate_batch result: usage must be an object, got ${JSON.stringify(raw)}`);
-  }
-  const obj = raw;
-  const field = (name, integer) => {
-    const v = obj[name];
-    if (typeof v !== "number" || !Number.isFinite(v) || v < 0 || integer && !Number.isInteger(v)) {
-      const kind = integer ? "a non-negative integer" : "a non-negative number";
-      throw new TypeError(`evaluate_batch result: usage.${name} must be ${kind}, got ${JSON.stringify(v)}`);
-    }
-    return v;
-  };
-  const ints = Object.fromEntries(INT_FIELDS.map((f) => [f, field(f, true)]));
-  const usd = Object.fromEntries(USD_FIELDS.map((f) => [f, field(f, false)]));
-  return { ...ints, ...usd };
-}
-function formatUsage(u) {
-  let line = `${u.model_calls} model calls \xB7 ${u.input_tokens + u.output_tokens} tokens (${u.cached_tokens} cached) \xB7 $${u.cost_usd.toFixed(4)} \xB7 retry cost $${u.retry_cost_usd.toFixed(4)}`;
-  if (u.budget_refused > 0) line += ` \xB7 ${u.budget_refused} calls refused by budget`;
-  if (u.unpriced_calls > 0) line += ` \xB7 ${u.unpriced_calls} unpriced calls not in $`;
-  return line;
-}
-function usageSummaryLine(u) {
-  if (u.model_calls === 0 && u.budget_refused === 0) return void 0;
-  return `attest usage: ${formatUsage(u)}`;
-}
-
-// src/client.ts
-var DEFAULT_TIMEOUT_MS = 3e4;
-var DEFAULT_DIAGNOSTIC_BUFFER = 32;
-var DEFAULT_DESYNC_THRESHOLD = 3;
-var DEFAULT_DESYNC_WINDOW_MS = 1e3;
-function resolveTimeoutMs(override) {
-  if (override !== void 0) return override;
-  const env = process.env["ATTEST_ENGINE_TIMEOUT"];
-  if (env !== void 0 && env !== "") {
-    const parsed = Number(env);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-      throw new Error(
-        `ATTEST_ENGINE_TIMEOUT must be a positive number of milliseconds, got: '${env}'`
-      );
-    }
-    return parsed;
-  }
-  return DEFAULT_TIMEOUT_MS;
-}
-function makeTimeoutPromise(method, timeoutMs) {
-  return new Promise((_, reject) => {
-    setTimeout(() => {
-      reject(new EngineTimeoutError(method, timeoutMs));
-    }, timeoutMs);
-  });
-}
-function debugProtocolEnabled() {
-  const flag = process.env["ATTEST_DEBUG_PROTOCOL"];
-  return flag === "1" || flag === "true" || flag === "yes";
-}
-function envLoggerDefault() {
-  if (debugProtocolEnabled()) {
-    return {
-      warn: (msg, ...args) => console.warn(msg, ...args),
-      error: (msg, ...args) => console.error(msg, ...args)
-    };
+function envLoggerDefault() {
+  if (debugProtocolEnabled()) {
+    return {
+      warn: (msg, ...args) => console.warn(msg, ...args),
+      error: (msg, ...args) => console.error(msg, ...args)
+    };
   }
   return {
     warn: () => {
@@ -734,6 +393,7 @@ var AttestClient = class {
   writeChain = Promise.resolve();
   readerActive = false;
   lineHandler = null;
+  attachedReader = null;
   logger;
   diagnosticBuffer;
   diagnosticListeners = /* @__PURE__ */ new Set();
@@ -763,6 +423,10 @@ var AttestClient = class {
   protocolDiagnostics() {
     return this.diagnosticBuffer.snapshot();
   }
+  /**
+   * Attach the id-routed reader to the engine's stdout. Idempotent; `sendRequest` starts it
+   * on first use, so calling it is optional.
+   */
   startReader() {
     if (this.readerActive) return;
     const rl = this.engine.readlineInterface;
@@ -770,23 +434,31 @@ var AttestClient = class {
       throw new Error("Engine readline interface not available. Call engine.start() first.");
     }
     this.readerActive = true;
+    this.attachedReader = rl;
     this.lineHandler = (line) => this.handleLine(line);
     rl.on("line", this.lineHandler);
     rl.on("close", () => {
-      this.failAll(new Error("Engine closed stdout."));
+      if (this.attachedReader !== rl) return;
+      const tail2 = this.engine.stderrTail ?? "";
+      this.failAll(
+        new Error(tail2 === "" ? "Engine closed stdout." : `Engine closed stdout. stderr:
+${tail2}`)
+      );
       this.readerActive = false;
+      this.attachedReader = null;
     });
   }
   stopReader() {
     if (!this.readerActive) return;
-    const rl = this.engine.readlineInterface;
+    const rl = this.attachedReader;
     if (rl !== null && this.lineHandler !== null) {
       rl.removeListener("line", this.lineHandler);
     }
     this.lineHandler = null;
     this.readerActive = false;
+    this.attachedReader = null;
   }
-  recordDiagnostic(kind, message, rawLine) {
+  recordDiagnostic(kind, message, rawLine, countsTowardDesync = true) {
     const diagnostic = {
       kind,
       message,
@@ -804,226 +476,851 @@ var AttestClient = class {
         );
       }
     }
-    this.maybeTriggerDesync(diagnostic.timestampMs);
+    if (countsTowardDesync) this.maybeTriggerDesync(diagnostic.timestampMs);
+  }
+  maybeTriggerDesync(nowMs) {
+    if (this.desynced) return;
+    const recent = this.diagnosticBuffer.countWithin(this.desyncWindowMs, nowMs);
+    if (recent >= this.desyncThreshold) {
+      this.desynced = true;
+      const snapshot = this.diagnosticBuffer.snapshot();
+      const err = new ProtocolDesyncError(
+        `Engine protocol desync: ${recent} unroutable response lines within ${this.desyncWindowMs}ms.`,
+        snapshot
+      );
+      this.logger.error(`[attest.protocol] ${err.message}`);
+      this.failAll(err);
+    }
+  }
+  handleLine(line) {
+    let response;
+    try {
+      response = decodeResponse(line);
+    } catch (err) {
+      this.handleDecodeFailure(line, err);
+      return;
+    }
+    let reqId;
+    try {
+      reqId = extractId(response);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.recordDiagnostic("missing_id", message, line, false);
+      return;
+    }
+    const pending = this.pending.get(reqId);
+    if (pending === void 0) {
+      this.recordDiagnostic(
+        "unknown_id",
+        `no pending request for id=${reqId}`,
+        line
+      );
+      return;
+    }
+    this.pending.delete(reqId);
+    try {
+      const result = extractResult(response);
+      pending.resolve(result);
+    } catch (err) {
+      pending.reject(err);
+    }
+  }
+  handleDecodeFailure(line, err) {
+    if (err instanceof ProtocolError) {
+      let reqId = -1;
+      try {
+        const raw = JSON.parse(line.trim());
+        const idCandidate = raw["id"];
+        if (typeof idCandidate === "number" && Number.isFinite(idCandidate)) {
+          reqId = idCandidate;
+        }
+      } catch {
+        reqId = -1;
+      }
+      const pending = this.pending.get(reqId);
+      if (pending !== void 0) {
+        this.pending.delete(reqId);
+        pending.reject(err);
+        return;
+      }
+      this.recordDiagnostic(
+        "non_routable_error",
+        `engine error code=${err.code} (${err.errorMessage}) had no matching pending id`,
+        line
+      );
+      return;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    const kind = classifyDecodeError(message);
+    this.recordDiagnostic(kind, message, line);
+  }
+  /** Reject every request still waiting for a response. */
+  rejectPending(err) {
+    this.failAll(err);
+  }
+  failAll(err) {
+    for (const pending of this.pending.values()) {
+      pending.reject(err);
+    }
+    this.pending.clear();
+  }
+  /**
+   * Send one request and resolve with the result of the response that carries its id.
+   *
+   * After a timeout the engine is restarted (its late response can no longer be matched),
+   * every other pending request is rejected, and the new engine gets the remaining session
+   * budget.
+   */
+  async sendRequest(method, params, timeoutMs) {
+    return this.send(method, params, timeoutMs, true);
+  }
+  /** `sendRequest` without the restart-on-timeout step, for the engine's own handshake. */
+  async sendWithoutRestart(method, params, timeoutMs) {
+    return this.send(method, params, timeoutMs, false);
+  }
+  async send(method, params, timeoutMs, restartOnTimeout) {
+    if (restartOnTimeout) await this.engine.whenReady?.();
+    const shared = this.engine.client;
+    if (shared !== void 0 && shared !== this) {
+      return restartOnTimeout ? shared.sendRequest(method, params, timeoutMs) : shared.sendWithoutRestart(method, params, resolveTimeoutMs(timeoutMs));
+    }
+    if (this.desynced) {
+      throw new ProtocolDesyncError(
+        "Engine protocol is desynced; AttestClient will not send further requests.",
+        this.diagnosticBuffer.snapshot()
+      );
+    }
+    const resolvedTimeout = resolveTimeoutMs(timeoutMs);
+    if (this.engine.isRunning === false) {
+      const tail2 = this.engine.stderrTail ?? "";
+      throw new Error(`Engine process is not running.${tail2 === "" ? "" : ` stderr:
+${tail2}`}`);
+    }
+    const cp = this.engine.childProcess;
+    if (cp === null || cp.stdin === null) {
+      throw new Error("Engine process not started.");
+    }
+    this.startReader();
+    const reservation = worstCaseReservation(method, params);
+    let capturedReqId;
+    let timer;
+    const requestPromise = new Promise((resolve5, reject) => {
+      this.writeChain = this.writeChain.then(() => {
+        this.requestId += 1;
+        const reqId = this.requestId;
+        capturedReqId = reqId;
+        this.pending.set(reqId, { resolve: resolve5, reject, reservation });
+        const requestStr = encodeRequest(reqId, method, params);
+        cp.stdin.write(requestStr, (err) => {
+          if (err) {
+            this.pending.delete(reqId);
+            reject(this.describeWriteError(err));
+          }
+        });
+      });
+    });
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new EngineTimeoutError(method, resolvedTimeout)), resolvedTimeout);
+    });
+    try {
+      return await Promise.race([requestPromise, timeoutPromise]);
+    } catch (err) {
+      if (err instanceof EngineTimeoutError) {
+        if (capturedReqId !== void 0) this.pending.delete(capturedReqId);
+        if (restartOnTimeout) await this.recoverFromTimeout(method, params, err);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** A failed pipe write names the engine's stderr tail; the original error stays as `cause` and `code`. */
+  describeWriteError(err) {
+    const tail2 = this.engine.stderrTail ?? "";
+    const wrapped = new Error(
+      `Failed to write to the engine: ${err.message}.${tail2 === "" ? "" : ` stderr:
+${tail2}`}`,
+      { cause: err }
+    );
+    return Object.assign(wrapped, { code: err.code });
+  }
+  async recoverFromTimeout(method, params, timeout) {
+    if (this.engine.restartAfterTimeout === void 0 || this.engine.client !== this) return;
+    const abandoned = [
+      worstCaseReservation(method, params),
+      ...[...this.pending.values()].map((p) => p.reservation)
+    ];
+    this.failAll(new Error(`Engine restarted after '${method}' timed out; request abandoned.`));
+    try {
+      await this.engine.restartAfterTimeout(abandoned);
+    } catch (err) {
+      throw new Error(
+        `Engine request '${method}' timed out and the engine could not be restarted: ` + (err instanceof Error ? err.message : String(err)),
+        { cause: timeout }
+      );
+    }
+  }
+  async evaluateBatch(trace, assertions, options2) {
+    if (isSimulationMode()) {
+      requireSimulationCapability(this.engine["initResult"]);
+    }
+    const params = {
+      trace,
+      assertions: [...assertions],
+      ...options2?.budget !== void 0 ? { budget: options2.budget } : {},
+      ...options2?.context !== void 0 ? { context: options2.context } : {}
+    };
+    let raw;
+    try {
+      raw = await this.sendRequest(
+        "evaluate_batch",
+        params,
+        options2?.timeout
+      );
+    } catch (err) {
+      if (err instanceof ProtocolError) this.engine.markUnknownSpend?.();
+      throw err;
+    }
+    const usage = parseUsage(raw["usage"]);
+    this.engine.recordUsage?.(usage);
+    const result = raw;
+    this.requireSentAssertionIds(assertions, result);
+    return { ...result, usage };
+  }
+  /** Reject a response whose assertion ids differ from the ids that were sent. */
+  requireSentAssertionIds(assertions, result) {
+    const sent = new Set(assertions.map((a) => a.assertion_id));
+    const returned = new Set((result.results ?? []).map((r) => r.assertion_id));
+    const missing = [...sent].filter((id) => !returned.has(id));
+    const unexpected = [...returned].filter((id) => !sent.has(id));
+    if (missing.length === 0 && unexpected.length === 0) return;
+    throw new ProtocolDesyncError(
+      `evaluate_batch response does not match the request: missing assertion ids [${missing.join(", ")}], unexpected [${unexpected.join(", ")}].`,
+      this.diagnosticBuffer.snapshot()
+    );
+  }
+  async submitPluginResult(traceId2, pluginName, assertionId2, status, score, explanation, options2) {
+    const result = {
+      assertion_id: assertionId2,
+      status,
+      score,
+      explanation,
+      cost: 0,
+      duration_ms: 0
+    };
+    const params = {
+      trace_id: traceId2,
+      plugin_name: pluginName,
+      assertion_id: assertionId2,
+      result
+    };
+    const raw = await this.sendRequest(
+      "submit_plugin_result",
+      params,
+      options2?.timeout
+    );
+    return Boolean(raw?.accepted ?? false);
+  }
+  async queryDrift(assertionId2, windowSize = 50, options2) {
+    if (isSimulationMode()) {
+      return {
+        assertion_id: assertionId2,
+        mean: 0,
+        stddev: 0,
+        count: 0,
+        latest_score: 0,
+        deviation: 0,
+        status: "no_data"
+      };
+    }
+    const raw = await this.sendRequest(
+      "query_drift",
+      {
+        assertion_id: assertionId2,
+        window_size: windowSize,
+        ...options2?.staticThreshold !== void 0 ? { static_threshold: options2.staticThreshold } : {}
+      },
+      options2?.timeout
+    );
+    return raw.report;
+  }
+  async generateUserMessage(persona, conversationHistory, faultConfig, options2) {
+    if (isSimulationMode()) {
+      return `[simulation] Hello from ${persona.name}`;
+    }
+    const params = {
+      persona,
+      conversation_history: conversationHistory
+    };
+    if (faultConfig !== void 0) {
+      params.fault_config = faultConfig;
+    }
+    let raw;
+    try {
+      raw = await this.sendRequest(
+        "generate_user_message",
+        params,
+        options2?.timeout
+      );
+    } catch (err) {
+      if (err instanceof ProtocolError) this.engine.markUnknownSpend?.();
+      throw err;
+    }
+    this.engine.markUnknownSpend?.();
+    return String(raw.message);
+  }
+};
+function worstCaseReservation(method, params) {
+  if (method === "generate_user_message") return { judgeCalls: null, usd: null };
+  if (method !== "evaluate_batch") return { judgeCalls: 0, usd: 0 };
+  const assertions = params["assertions"] ?? [];
+  const judges = assertions.some((a) => a.type === "llm_judge");
+  const paid = judges || assertions.some((a) => a.type === "embedding");
+  const budget = params["budget"];
+  return {
+    judgeCalls: judges ? budget?.max_judge_calls ?? null : 0,
+    usd: paid ? budget?.max_cost_usd ?? null : 0
+  };
+}
+function classifyDecodeError(message) {
+  if (message.startsWith("malformed JSON")) return "malformed_json";
+  if (message.startsWith("expected JSON object")) return "non_object_response";
+  if (message.startsWith("invalid jsonrpc version")) return "invalid_jsonrpc_version";
+  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/engine-downloader.ts
+import * as https from "https";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+import { fileURLToPath } from "url";
+var RELEASE_BASE = `https://github.com/attest-framework/attest/releases/download/v${ENGINE_VERSION}`;
+var TABLE_NAME = "engine-checksums.json";
+var MAX_REDIRECTS = 5;
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+var DEFAULT_TOTAL_TIMEOUT_MS = 12e4;
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+function versionedBinDir() {
+  return path.join(os.homedir(), ".attest", "bin", ENGINE_VERSION);
+}
+function platformKey() {
+  const platform2 = os.platform();
+  const arch2 = os.arch();
+  const mapping = {
+    darwin: { arm64: "darwin-arm64", x64: "darwin-amd64" },
+    linux: { arm64: "linux-arm64", x64: "linux-amd64" },
+    win32: { x64: "windows-amd64", arm64: "windows-arm64" }
+  };
+  const osMap = mapping[platform2];
+  if (!osMap) {
+    throw new Error(
+      `Unsupported platform: ${platform2}. Supported: darwin, linux, win32.`
+    );
+  }
+  const key = osMap[arch2];
+  if (!key) {
+    throw new Error(
+      `Unsupported architecture '${arch2}' on platform '${platform2}'. Supported architectures: ${Object.keys(osMap).join(", ")}.`
+    );
+  }
+  return key;
+}
+function binaryFilename() {
+  return os.platform() === "win32" ? "attest-engine.exe" : "attest-engine";
+}
+function cachedEnginePath() {
+  const binPath = path.join(versionedBinDir(), binaryFilename());
+  return fs.statSync(binPath, { throwIfNoEntry: false })?.isFile() ? binPath : null;
+}
+function packageRoot() {
+  let dir = typeof __dirname === "string" ? __dirname : path.dirname(fileURLToPath(import.meta.url));
+  while (!fs.existsSync(path.join(dir, "package.json"))) {
+    const parent = path.dirname(dir);
+    if (parent === dir) return dir;
+    dir = parent;
+  }
+  return dir;
+}
+function embeddedHash(key, tablePath) {
+  if (!fs.existsSync(tablePath)) {
+    throw new Error(
+      `This @attest-ai/core install has no embedded engine hash table (${TABLE_NAME}), which is how a source or workspace install looks, so it never downloads an engine. Point ATTEST_ENGINE_PATH at an engine binary, or build one with \`make engine\` and set ATTEST_ENGINE_PATH=./bin/attest-engine.`
+    );
+  }
+  let hash;
+  try {
+    const table = JSON.parse(fs.readFileSync(tablePath, "utf-8"));
+    hash = table[ENGINE_VERSION]?.[key];
+  } catch (err) {
+    throw new Error(
+      `@attest-ai/core ${VERSION} ships an unreadable engine hash table at ${tablePath}: ${String(err)}`
+    );
+  }
+  if (typeof hash !== "string" || !SHA256_HEX.test(hash)) {
+    throw new Error(
+      `@attest-ai/core ${VERSION} ships no valid engine hash for v${ENGINE_VERSION} on ${key} in ${tablePath}.`
+    );
+  }
+  return hash;
+}
+function httpsGet(url, o) {
+  return new Promise((resolve5, reject) => {
+    let current;
+    let done = false;
+    const finish = (err, data) => {
+      if (done) return;
+      done = true;
+      clearTimeout(deadline);
+      if (err) {
+        current?.destroy();
+        reject(err);
+      } else {
+        resolve5(data);
+      }
+    };
+    const deadline = setTimeout(
+      () => finish(new Error(`Timed out after ${o.totalTimeoutMs}ms fetching ${url}`)),
+      o.totalTimeoutMs
+    );
+    const hop = (target, redirects) => {
+      if (redirects > MAX_REDIRECTS) {
+        finish(new Error(`Too many redirects (>${MAX_REDIRECTS}) following ${url}`));
+        return;
+      }
+      let parsed;
+      try {
+        parsed = new URL(target);
+      } catch {
+        finish(new Error(`Invalid URL: ${target}`));
+        return;
+      }
+      if (parsed.protocol !== "https:") {
+        finish(new Error(`Refusing to download over a non-https URL: ${target}`));
+        return;
+      }
+      current = https.get(parsed, { ca: o.ca, timeout: o.connectTimeoutMs }, (res) => {
+        const status = res.statusCode ?? 0;
+        if (REDIRECT_STATUSES.has(status)) {
+          res.resume();
+          const location = res.headers.location;
+          if (!location) {
+            finish(new Error(`Redirect ${status} without Location header from ${target}`));
+            return;
+          }
+          let next;
+          try {
+            next = new URL(location, parsed).toString();
+          } catch {
+            finish(new Error(`Invalid redirect Location ${JSON.stringify(location)} from ${target}`));
+            return;
+          }
+          hop(next, redirects + 1);
+          return;
+        }
+        if (status !== 200) {
+          res.resume();
+          finish(new Error(`HTTP ${status} fetching ${target}`));
+          return;
+        }
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => finish(null, Buffer.concat(chunks)));
+        res.on("error", (err) => finish(err));
+      });
+      current.on(
+        "timeout",
+        () => finish(new Error(`No response within ${o.connectTimeoutMs}ms from ${target}`))
+      );
+      current.on("error", (err) => finish(err));
+    };
+    hop(url, 0);
+  });
+}
+async function downloadEngine(options2 = {}) {
+  const key = platformKey();
+  const filename = `attest-engine-${key}${os.platform() === "win32" ? ".exe" : ""}`;
+  const expectedHash = embeddedHash(key, options2.tablePath ?? path.join(packageRoot(), TABLE_NAME));
+  const binaryUrl = `${options2.releaseBase ?? RELEASE_BASE}/${filename}`;
+  process.stderr.write(`[attest] Downloading engine v${ENGINE_VERSION} for ${key}...
+`);
+  let data;
+  try {
+    data = await httpsGet(binaryUrl, {
+      ca: options2.ca,
+      connectTimeoutMs: options2.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS,
+      totalTimeoutMs: options2.totalTimeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS
+    });
+  } catch (err) {
+    throw new Error(`Failed to download engine from ${binaryUrl}: ${err.message}`);
+  }
+  const actualHash = crypto.createHash("sha256").update(data).digest("hex");
+  if (actualHash !== expectedHash) {
+    throw new Error(
+      `${filename} does not match the hash shipped in @attest-ai/core ${VERSION}: expected ${expectedHash}, got ${actualHash}. Refusing to install it. Retry, or set ATTEST_ENGINE_PATH to a binary you trust.`
+    );
+  }
+  process.stderr.write(`[attest] Checksum verified.
+`);
+  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;
+}
+
+// src/engine-manager.ts
+var ENGINE_BINARY_NAME = "attest-engine";
+var VERSION_PROBE_TIMEOUT_MS = 1e4;
+var DEFAULT_INITIALIZE_TIMEOUT_MS = 3e4;
+var SHUTDOWN_TIMEOUT_MS = 5e3;
+var STDERR_TAIL_BYTES = 4096;
+var EXIT_REPORT_GRACE_MS = 1e3;
+var PIPE_WRITE_ERROR_CODES = /* @__PURE__ */ new Set(["EPIPE", "ECONNRESET", "ERR_STREAM_DESTROYED"]);
+function isPipeWriteError(err) {
+  for (let e = err; e instanceof Error; e = e.cause) {
+    const code = e.code;
+    if (code !== void 0 && PIPE_WRITE_ERROR_CODES.has(code)) return true;
+  }
+  return false;
+}
+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;
+  }
+};
+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(candidate, fsConstants.X_OK);
+    } catch {
+      continue;
+    }
+    if (statSync2(candidate).isFile()) return candidate;
+  }
+  return null;
+}
+function requireFile(enginePath, label) {
+  if (!existsSync2(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 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}' ${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 [await downloadEngine(), "download"];
+}
+async function resolveEngine(explicitPath, options2 = {}) {
+  const [enginePath, source] = await locateEngine(explicitPath, options2.allowDownload ?? true);
+  const found = engineVersion(enginePath);
+  if (found !== ENGINE_VERSION) {
+    throw new EngineVersionMismatchError(enginePath, source, found, ENGINE_VERSION);
+  }
+  return enginePath;
+}
+function envNumber(name) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return null;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+async function reportExit(exited, graceMs) {
+  let timer;
+  const grace = new Promise((done) => {
+    timer = setTimeout(done, graceMs);
+  });
+  try {
+    await Promise.race([exited, grace]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var EngineManager = class {
+  enginePath;
+  logLevel;
+  initializeTimeoutMs;
+  process = null;
+  reader = null;
+  initialized = false;
+  initResult = null;
+  routedClient;
+  /** The running engine's stderr tail; each launch owns a fresh one so a killed engine cannot write into it. */
+  stderr = { text: "" };
+  restarting = null;
+  configuredBudget = { judgeCalls: null, usd: null };
+  usedJudgeCalls = 0;
+  usedUsd = 0;
+  heldJudgeCalls = 0;
+  heldUsd = 0;
+  /** Spend the SDK cannot observe may have happened; a restart then leaves no budget. */
+  unknownSpend = false;
+  constructor(options2) {
+    this.enginePath = options2?.enginePath ?? "";
+    this.logLevel = options2?.logLevel ?? "warn";
+    this.initializeTimeoutMs = options2?.initializeTimeoutMs ?? DEFAULT_INITIALIZE_TIMEOUT_MS;
   }
-  maybeTriggerDesync(nowMs) {
-    if (this.desynced) return;
-    const recent = this.diagnosticBuffer.countWithin(this.desyncWindowMs, nowMs);
-    if (recent >= this.desyncThreshold) {
-      this.desynced = true;
-      const snapshot = this.diagnosticBuffer.snapshot();
-      const err = new ProtocolDesyncError(
-        `Engine protocol desync: ${recent} unroutable response lines within ${this.desyncWindowMs}ms.`,
-        snapshot
-      );
-      this.logger.error(`[attest.protocol] ${err.message}`);
-      this.failAll(err);
-    }
+  /**
+   * Start the engine and complete the `initialize` handshake. Rejects when the engine exits,
+   * closes its pipes or fails to answer within the initialize timeout; the error carries the
+   * tail of the engine's stderr.
+   */
+  async start() {
+    this.enginePath = await resolveEngine(this.enginePath || void 0);
+    this.configuredBudget = {
+      judgeCalls: envNumber("ATTEST_MAX_JUDGE_CALLS"),
+      usd: envNumber("ATTEST_BUDGET_USD")
+    };
+    this.usedJudgeCalls = this.usedUsd = this.heldJudgeCalls = this.heldUsd = 0;
+    this.unknownSpend = false;
+    this.initResult = await this.launch(void 0);
+    this.initialized = true;
+    return this.initResult;
   }
-  handleLine(line) {
-    let response;
-    try {
-      response = decodeResponse(line);
-    } catch (err) {
-      this.handleDecodeFailure(line, err);
-      return;
-    }
-    let reqId;
+  /** Spawn the engine and run `initialize` on it; the engine is stopped when that fails. */
+  async launch(envOverrides) {
+    const stderr = { text: "" };
+    this.stderr = stderr;
+    const child = spawn(this.enginePath, [`--log-level=${this.logLevel}`], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...envOverrides }
+    });
+    this.process = child;
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr.text = (stderr.text + chunk).slice(-STDERR_TAIL_BYTES);
+    });
+    child.stdin.on("error", () => void 0);
+    this.reader = createInterface({ input: child.stdout });
+    const client = new AttestClient(this);
+    this.routedClient = client;
+    client.startReader();
+    const exited = new Promise((_, reject) => {
+      child.once("error", (err) => reject(new Error(`attest-engine failed to start: ${err.message}`)));
+      child.once("close", (code, signal) => {
+        const how = signal !== null ? `signal ${signal}` : `exit code ${String(code)}`;
+        reject(
+          new Error(
+            `attest-engine exited before it was ready (${how}).` + (stderr.text === "" ? "" : ` stderr:
+${stderr.text.trimEnd()}`)
+          )
+        );
+      });
+    });
+    exited.catch(() => void 0);
     try {
-      reqId = extractId(response);
+      return await Promise.race([this.initialize(client), exited]);
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.recordDiagnostic("missing_id", message, line);
-      return;
+      await this.terminate();
+      if (isPipeWriteError(err)) await reportExit(exited, EXIT_REPORT_GRACE_MS);
+      throw err;
     }
-    const pending = this.pending.get(reqId);
-    if (pending === void 0) {
-      this.recordDiagnostic(
-        "unknown_id",
-        `no pending request for id=${reqId}`,
-        line
+  }
+  /** Send initialize and check the engine's version and capabilities. */
+  async initialize(client) {
+    const init = await client.sendWithoutRestart(
+      "initialize",
+      {
+        sdk_name: "attest-typescript",
+        sdk_version: VERSION,
+        protocol_version: 1,
+        required_capabilities: ["layers_1_4"],
+        preferred_encoding: "json"
+      },
+      this.initializeTimeoutMs
+    );
+    if (init.engine_version !== ENGINE_VERSION) {
+      throw new EngineVersionMismatchError(
+        this.enginePath,
+        "initialize",
+        init.engine_version,
+        ENGINE_VERSION
       );
-      return;
     }
-    this.pending.delete(reqId);
-    try {
-      const result = extractResult(response);
-      pending.resolve(result);
-    } catch (err) {
-      pending.reject(err);
+    if (!init.compatible) {
+      throw new Error(`Engine incompatible. Missing capabilities: ${JSON.stringify(init.missing)}`);
     }
+    return init;
   }
-  handleDecodeFailure(line, err) {
-    if (err instanceof ProtocolError) {
-      let reqId = -1;
+  async stop() {
+    if (this.restarting !== null) await this.restarting.catch(() => void 0);
+    if (this.process === null) return;
+    if (this.initialized && this.routedClient !== void 0 && this.isRunning) {
       try {
-        const raw = JSON.parse(line.trim());
-        const idCandidate = raw["id"];
-        if (typeof idCandidate === "number" && Number.isFinite(idCandidate)) {
-          reqId = idCandidate;
-        }
+        await this.routedClient.sendWithoutRestart("shutdown", {}, SHUTDOWN_TIMEOUT_MS);
       } catch {
-        reqId = -1;
-      }
-      const pending = this.pending.get(reqId);
-      if (pending !== void 0) {
-        this.pending.delete(reqId);
-        pending.reject(err);
-        return;
       }
-      this.recordDiagnostic(
-        "non_routable_error",
-        `engine error code=${err.code} (${err.errorMessage}) had no matching pending id`,
-        line
-      );
-      return;
     }
-    const message = err instanceof Error ? err.message : String(err);
-    const kind = classifyDecodeError(message);
-    this.recordDiagnostic(kind, message, line);
+    await this.terminate();
+    this.initialized = false;
   }
-  failAll(err) {
-    for (const pending of this.pending.values()) {
-      pending.reject(err);
+  /** Close the pipes, reject pending requests and stop the engine process (SIGKILL when `force`). */
+  async terminate(force = false) {
+    const child = this.process;
+    this.routedClient?.stopReader();
+    this.routedClient?.rejectPending(new Error("Engine stopped."));
+    this.reader?.close();
+    this.reader = null;
+    this.process = null;
+    if (child === null) return;
+    if (child.exitCode === null && child.signalCode === null) {
+      await new Promise((res) => {
+        const timer = force ? void 0 : setTimeout(() => child.kill("SIGKILL"), 5e3);
+        child.once("exit", () => {
+          clearTimeout(timer);
+          res();
+        });
+        child.kill(force ? "SIGKILL" : "SIGTERM");
+      });
     }
-    this.pending.clear();
   }
-  async sendRequest(method, params, timeoutMs) {
-    if (this.desynced) {
-      throw new ProtocolDesyncError(
-        "Engine protocol is desynced; AttestClient will not send further requests.",
-        this.diagnosticBuffer.snapshot()
-      );
+  /**
+   * Replace the engine after a request timed out: its late response can no longer be told
+   * apart from a new one. The new engine gets the remaining session budget: the configured
+   * limit minus the usage already returned, minus what the abandoned requests may still have
+   * reserved. A restart that leaves no budget makes later model calls
+   * `not_evaluated(budget_exhausted)`.
+   */
+  restartAfterTimeout(abandoned) {
+    for (const r of abandoned) {
+      this.heldJudgeCalls += r.judgeCalls ?? Number.POSITIVE_INFINITY;
+      this.heldUsd += r.usd ?? Number.POSITIVE_INFINITY;
     }
-    const resolvedTimeout = resolveTimeoutMs(timeoutMs);
-    if (!this.readerActive) {
-      return Promise.race([
-        this.engine.sendRequest(method, params),
-        makeTimeoutPromise(method, resolvedTimeout)
-      ]);
+    this.restarting ??= this.restart().finally(() => {
+      this.restarting = null;
+    });
+    return this.restarting;
+  }
+  /** An engine reply the SDK cannot account for (no usage, an RPC error, a dropped reply) may have spent budget. */
+  markUnknownSpend() {
+    this.unknownSpend = true;
+  }
+  async restart() {
+    await this.terminate(true);
+    const overrides = {};
+    const { judgeCalls, usd } = this.configuredBudget;
+    const unknown = this.unknownSpend ? Number.POSITIVE_INFINITY : 0;
+    if (judgeCalls !== null) {
+      overrides["ATTEST_MAX_JUDGE_CALLS"] = String(
+        Math.max(0, Math.floor(judgeCalls - this.usedJudgeCalls - this.heldJudgeCalls - unknown))
+      );
     }
-    const cp = this.engine.childProcess;
-    if (cp === null || cp.stdin === null) {
-      throw new Error("Engine process not started.");
+    if (usd !== null) {
+      overrides["ATTEST_BUDGET_USD"] = String(Math.max(0, usd - this.usedUsd - this.heldUsd - unknown));
     }
-    let capturedReqId;
-    const requestPromise = new Promise((resolve5, reject) => {
-      this.writeChain = this.writeChain.then(() => {
-        this.requestId += 1;
-        const reqId = this.requestId;
-        capturedReqId = reqId;
-        this.pending.set(reqId, { resolve: resolve5, reject });
-        const requestStr = encodeRequest(reqId, method, params);
-        cp.stdin.write(requestStr, (err) => {
-          if (err) {
-            this.pending.delete(reqId);
-            reject(err);
-          }
-        });
-      });
-    });
-    const timeoutPromise = makeTimeoutPromise(method, resolvedTimeout);
-    return Promise.race([requestPromise, timeoutPromise]).catch((err) => {
-      if (err instanceof EngineTimeoutError && capturedReqId !== void 0) {
-        this.pending.delete(capturedReqId);
-      }
-      throw err;
-    });
+    this.initResult = await this.launch(overrides);
   }
-  async evaluateBatch(trace, assertions, options2) {
-    if (isSimulationMode()) {
-      requireSimulationCapability(this.engine["initResult"]);
-    }
-    const params = {
-      trace,
-      assertions: [...assertions],
-      ...options2?.budget !== void 0 ? { budget: options2.budget } : {},
-      ...options2?.context !== void 0 ? { context: options2.context } : {}
-    };
-    const raw = await this.sendRequest(
-      "evaluate_batch",
-      params,
-      options2?.timeout
-    );
-    return { ...raw, usage: parseUsage(raw["usage"]) };
+  /** Count the usage an evaluate_batch result reported against the session budget. */
+  recordUsage(usage) {
+    this.usedJudgeCalls += usage.judge_calls;
+    this.usedUsd += usage.cost_usd;
   }
-  async submitPluginResult(traceId2, pluginName, assertionId2, status, score, explanation, options2) {
-    const result = {
-      assertion_id: assertionId2,
-      status,
-      score,
-      explanation,
-      cost: 0,
-      duration_ms: 0
-    };
-    const params = {
-      trace_id: traceId2,
-      plugin_name: pluginName,
-      assertion_id: assertionId2,
-      result
-    };
-    const raw = await this.sendRequest(
-      "submit_plugin_result",
-      params,
-      options2?.timeout
-    );
-    return Boolean(raw?.accepted ?? false);
+  /** Resolves once an engine restart in progress has finished. */
+  async whenReady() {
+    if (this.restarting !== null) await this.restarting;
   }
-  async queryDrift(assertionId2, windowSize = 50, options2) {
-    if (isSimulationMode()) {
-      return {
-        assertion_id: assertionId2,
-        mean: 0,
-        stddev: 0,
-        count: 0,
-        latest_score: 0,
-        deviation: 0,
-        status: "no_data"
-      };
-    }
-    const raw = await this.sendRequest(
-      "query_drift",
-      { assertion_id: assertionId2, window_size: windowSize },
-      options2?.timeout
-    );
-    return raw.report;
+  /** Tail of the engine's stderr: the reason an engine died. */
+  get stderrTail() {
+    return this.stderr.text.trimEnd();
   }
-  async generateUserMessage(persona, conversationHistory, faultConfig, options2) {
-    if (isSimulationMode()) {
-      return `[simulation] Hello from ${persona.name}`;
-    }
-    const params = {
-      persona,
-      conversation_history: conversationHistory
-    };
-    if (faultConfig !== void 0) {
-      params.fault_config = faultConfig;
+  /** The client that routes this engine's responses by id; replaced when the engine restarts. */
+  get client() {
+    return this.routedClient;
+  }
+  async sendRequest(method, params) {
+    if (!this.initialized && method !== "initialize") {
+      throw new Error("Engine not initialized. Call start() first.");
     }
-    const raw = await this.sendRequest(
-      "generate_user_message",
-      params,
-      options2?.timeout
-    );
-    return String(raw.message);
+    if (this.routedClient === void 0) throw new Error("Engine process not started.");
+    return this.routedClient.sendRequest(method, params);
   }
-};
-function classifyDecodeError(message) {
-  if (message.startsWith("malformed JSON")) return "malformed_json";
-  if (message.startsWith("expected JSON object")) return "non_object_response";
-  if (message.startsWith("invalid jsonrpc version")) return "invalid_jsonrpc_version";
-  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");
+  get isRunning() {
+    return this.process !== null && this.process.exitCode === null && this.process.signalCode === null;
   }
-  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.`
-    );
+  /** Expose process for AttestClient reader loop access */
+  get childProcess() {
+    return this.process;
   }
-}
+  /** Expose readline interface for AttestClient reader loop */
+  get readlineInterface() {
+    return this.reader;
+  }
+};
 
 // src/trace.ts
 import { randomUUID } from "crypto";
@@ -1578,12 +1875,26 @@ var WorldChecks = class {
     );
   }
 };
+var chainObserver;
+function setChainObserver(observer) {
+  chainObserver = observer;
+}
 var ExpectChain = class {
   _result;
   _assertions = [];
   _worldBytes = 0;
+  _evaluated = false;
   constructor(result) {
     this._result = result;
+    chainObserver?.(this);
+  }
+  /** True once the chain was handed to an evaluation. */
+  get evaluated() {
+    return this._evaluated;
+  }
+  /** Record that the chain was handed to an evaluation. */
+  markEvaluated() {
+    this._evaluated = true;
   }
   get assertions() {
     return [...this._assertions];
@@ -2513,19 +2824,109 @@ var ExpectChain = class {
       soft: opts?.soft ?? false
     });
   }
-};
-function attestExpect(result) {
-  if (result instanceof AgentResult) {
-    return new ExpectChain(result);
+};
+function attestExpect(result) {
+  if (result instanceof AgentResult) {
+    return new ExpectChain(result);
+  }
+  return new ExpectChain(new AgentResult(result));
+}
+
+// src/assertion-id.ts
+import { createHash as createHash2 } from "crypto";
+var ID_SCHEME = 2;
+function lonelySurrogateAt(text) {
+  for (let i = 0; i < text.length; i++) {
+    const unit = text.charCodeAt(i);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = text.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        i++;
+        continue;
+      }
+      return i;
+    }
+    if (unit >= 56320 && unit <= 57343) return i;
+  }
+  return -1;
+}
+function describe(identity) {
+  if (identity === void 0) return "";
+  return ` (assertion type ${JSON.stringify(identity.type)}, scope ${JSON.stringify(identity.scopeId)})`;
+}
+function jcsString(text, where, identity) {
+  const at = lonelySurrogateAt(text);
+  if (at >= 0) {
+    throw new Error(
+      `assertion id: ${where} contains an unpaired surrogate at UTF-16 index ${at}; it has no UTF-8 form${describe(identity)}`
+    );
+  }
+  return JSON.stringify(text);
+}
+function jcs(value, where, identity) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string":
+      return jcsString(value, where, identity);
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw new Error(`assertion id: ${where} is ${String(value)}, which JSON cannot represent${describe(identity)}`);
+      }
+      return String(value);
+    case "object": {
+      if (Array.isArray(value)) {
+        return `[${value.map((item, i) => jcs(item === void 0 ? null : item, `${where}[${i}]`, identity)).join(",")}]`;
+      }
+      const record2 = value;
+      const keys = Object.keys(record2).filter((k) => record2[k] !== void 0).sort();
+      const members = keys.map((key) => {
+        const quoted = jcsString(key, `${where} key ${JSON.stringify(key)}`, identity);
+        return `${quoted}:${jcs(record2[key], `${where}.${key}`, identity)}`;
+      });
+      return `{${members.join(",")}}`;
+    }
+    default:
+      throw new Error(`assertion id: ${where} has non-JSON type ${typeof value}${describe(identity)}`);
   }
-  return new ExpectChain(new AgentResult(result));
 }
+function canonicalSpec(spec, identity) {
+  return jcs(spec ?? {}, "spec", identity);
+}
+function canonicalIdInput(scopeId, type, spec, occurrenceIndex) {
+  const identity = { scopeId, type, spec };
+  if (!Number.isInteger(occurrenceIndex) || occurrenceIndex < 0) {
+    throw new Error(`assertion id: occurrence index must be an integer >= 0, got ${String(occurrenceIndex)}`);
+  }
+  return `[${jcsString(scopeId, "scope_id", identity)},${jcsString(type, "assertion_type", identity)},${canonicalSpec(spec, identity)},${occurrenceIndex}]`;
+}
+function assertionIdOf(scopeId, type, spec, occurrenceIndex) {
+  const input = canonicalIdInput(scopeId, type, spec, occurrenceIndex);
+  return `a2_${createHash2("sha256").update(input, "utf8").digest("hex").slice(0, 32)}`;
+}
+var AssertionIdAssigner = class {
+  constructor(scopeId) {
+    this.scopeId = scopeId;
+    if (scopeId === "") throw new Error("assertion id: scope id must not be empty");
+  }
+  scopeId;
+  seen = /* @__PURE__ */ new Map();
+  next(type, spec) {
+    const key = `${jcsString(type, "assertion_type", { scopeId: this.scopeId, type, spec })}\0${canonicalSpec(spec, { scopeId: this.scopeId, type, spec })}`;
+    const occurrence = this.seen.get(key) ?? 0;
+    const id = assertionIdOf(this.scopeId, type, spec, occurrence);
+    this.seen.set(key, occurrence + 1);
+    return id;
+  }
+};
 
 // src/capture.ts
 import { spawn as spawn2 } from "child_process";
 import * as fs2 from "fs";
+import * as os2 from "os";
 import * as path2 from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var FIXTURE_VERSION = 1;
 var DEFAULT_FIXTURE_DIR = path2.join("tests", "attest", "fixtures");
 var CaptureError = class extends Error {
@@ -2538,7 +2939,7 @@ var CaptureError = class extends Error {
   }
 };
 function toPath(p) {
-  return p instanceof URL ? fileURLToPath(p) : p;
+  return p instanceof URL ? fileURLToPath2(p) : p;
 }
 function loadFixture(file) {
   const p = toPath(file);
@@ -2662,7 +3063,75 @@ function testPathFor(fixturePath) {
   const name = path2.basename(fixturePath).replace(/\.attest\.json$/, "");
   return path2.join(path2.dirname(path2.dirname(fixturePath)), `${name}.test.ts`);
 }
-function renderVitest(fixture, fixturePath, testPath) {
+function relUrl(target, testPath) {
+  const rel = path2.relative(path2.dirname(testPath), target).split(path2.sep).join("/");
+  const url = rel === "" ? "." : rel;
+  return `new URL(${ts(url.startsWith(".") ? url : `./${url}`)}, import.meta.url)`;
+}
+function chainLines(calls, subject, param) {
+  const lines = [`function contracts(${param}): ExpectChain {`, `  return attestExpect(${subject})`];
+  for (const [c, dsl] of calls) {
+    lines.push(`    // ${comment(`${c.id}: ${c.description}`)}`, `    ${dsl}`);
+  }
+  lines[lines.length - 1] += ";";
+  lines.push("}");
+  return lines;
+}
+function skippedLines(skipped) {
+  if (skipped.length === 0) return [];
+  return ["", "// Drafted contracts without a TypeScript DSL call (left out):", ...skipped.map((s) => `// - ${comment(s)}`)];
+}
+function renderReplay(fixture, calls, skipped, fixturePath, testPath, rerun) {
+  const meaning = fixture.verification.expect_fail ? [
+    "// The recording is an incident: these contracts failed on it. The test passes once",
+    "// the new run satisfies them, so it fails again if the agent regresses."
+  ] : ["// The test fails when the agent's behavior stops satisfying them."];
+  const world = rerun.world === void 0 ? "undefined" : relUrl(rerun.world, testPath);
+  const lines = [
+    `// Replay test drafted by \`attest capture\` from fixture ${comment(ts(fixture.name))}.`,
+    "//",
+    "// Re-runs COMMAND, the source command of the fixture, under strict replay (the engine's",
+    "// `replay --mode strict --no-live`): OpenAI- and Anthropic-compatible calls are served",
+    "// from the recording, and one that matches no recording fails the test. Other providers",
+    "// are not blocked: run this test without their credentials. The drafted contracts are",
+    "// evaluated on the NEW run's trace, not on the recording.",
+    "//",
+    "// COMMAND is what this test runs and is reviewed with the test: if the fixture's",
+    "// source.command stops matching it, the test fails instead of running the fixture's.",
+    ...meaning,
+    "//",
+    "// A pass means the new run is consistent with the recording and satisfies the drafted",
+    "// contracts; it does not prove the agent correct. Identities are compared by role",
+    "// (relative identity): a run that swaps who plays which role misses, while the absolute",
+    "// identity is not checked. Review and edit before committing. Re-capturing does not",
+    "// overwrite this file.",
+    `import { attestExpect, replayRun, type ExpectChain } from "@attest-ai/core";`,
+    `import type { Trace } from "@attest-ai/core/proto";`,
+    `import { evaluate } from "@attest-ai/vitest";`,
+    `import { describe, it } from "vitest";`,
+    "",
+    `const FIXTURE = ${relUrl(fixturePath, testPath)};`,
+    "// The directory `attest capture` ran in: the source command's relative paths start here.",
+    `const RUN_DIR = ${relUrl(rerun.cwd, testPath)};`,
+    `const WORLD = ${world};`,
+    "// Reviewed argv: the only command this test runs.",
+    `const COMMAND = ${ts(fixture.source.command ?? [])};`,
+    ...skippedLines(skipped),
+    "",
+    ...chainLines(calls, "trace", "trace: Trace"),
+    "",
+    `describe(${ts(fixture.name)}, () => {`,
+    `  it("new run is consistent with the recording", async () => {`,
+    "    const trace = await replayRun(FIXTURE, { command: COMMAND, cwd: RUN_DIR, world: WORLD });",
+    "",
+    "    await evaluate(contracts(trace));",
+    "  });",
+    "});"
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function renderVitest(fixture, fixturePath, testPath, rerun) {
   const calls = [];
   const skipped = [];
   for (const c of fixture.contracts) {
@@ -2672,7 +3141,9 @@ function renderVitest(fixture, fixturePath, testPath) {
       skipped.push(err.message);
     }
   }
-  const rel = path2.relative(path2.dirname(testPath), fixturePath).split(path2.sep).join("/");
+  if (rerun !== void 0 && fixture.source.kind === "command" && fixture.source.replay_capable) {
+    return renderReplay(fixture, calls, skipped, fixturePath, testPath, rerun);
+  }
   const status = new Map(fixture.verification.results.map((r) => [r.contract, r.status]));
   const expectFail = fixture.verification.expect_fail;
   const lines = [
@@ -2684,18 +3155,11 @@ function renderVitest(fixture, fixturePath, testPath) {
     `import { ${expectFail ? "inspect" : "evaluate"} } from "@attest-ai/vitest";`,
     `import { describe, ${expectFail ? "expect, " : ""}it } from "vitest";`,
     "",
-    `const FIXTURE = loadFixture(new URL(${ts(rel.startsWith(".") ? rel : `./${rel}`)}, import.meta.url));`
+    `const FIXTURE = loadFixture(${relUrl(fixturePath, testPath)});`,
+    ...skippedLines(skipped),
+    "",
+    ...chainLines(calls, "FIXTURE.trace", "")
   ];
-  if (skipped.length > 0) {
-    lines.push("", "// Drafted contracts without a TypeScript DSL call (left out):");
-    for (const s of skipped) lines.push(`// - ${comment(s)}`);
-  }
-  lines.push("", "function contracts(): ExpectChain {", "  return attestExpect(FIXTURE.trace)");
-  for (const [c, dsl] of calls) {
-    lines.push(`    // ${comment(`${c.id}: ${c.description}`)}`, `    ${dsl}`);
-  }
-  lines[lines.length - 1] += ";";
-  lines.push("}");
   if (expectFail) {
     lines.push("", "// Status of each contract on the captured incident, in contracts() order.");
     lines.push("const EXPECTED: Array<[string, string]> = [");
@@ -2724,14 +3188,14 @@ function renderVitest(fixture, fixturePath, testPath) {
   return `${lines.join("\n")}
 `;
 }
-function emitVitest(fixturePath) {
+function emitVitest(fixturePath, rerun) {
   const testPath = testPathFor(fixturePath);
   const existing = fs2.lstatSync(testPath, { throwIfNoEntry: false });
   if (existing?.isSymbolicLink()) {
     throw new CaptureError(`${testPath} is a symbolic link; refusing to draft a test through it`);
   }
   if (existing !== void 0) return null;
-  const source = renderVitest(loadFixture(fixturePath), fixturePath, testPath);
+  const source = renderVitest(loadFixture(fixturePath), fixturePath, testPath, rerun);
   fs2.mkdirSync(path2.dirname(testPath), { recursive: true });
   try {
     fs2.writeFileSync(testPath, source, { encoding: "utf8", flag: "wx" });
@@ -2743,6 +3207,108 @@ function emitVitest(fixturePath) {
   }
   return testPath;
 }
+var OTHER_PROVIDER_KEYS = ["ANTHROPIC_API_KEY", "GOOGLE_API_KEY", "GEMINI_API_KEY"];
+var REPLAY_TIMEOUT_MS = 3e5;
+var REDACTED_MARKER = "[redacted]";
+var PLACEHOLDER = /\{\{(?:id|email|timestamp)_\d+\}\}/;
+var STDERR_TAIL = 4e3;
+async function replayRun(fixture, options2) {
+  const fp = path2.resolve(toPath(fixture));
+  const doc = loadFixture(fp);
+  const recorded = doc.source.command;
+  if (doc.source.kind !== "command" || !doc.source.replay_capable || !recorded || recorded.length === 0) {
+    throw new CaptureError(`${fp}: not a command capture with recorded exchanges; cannot replay`);
+  }
+  const command = [...options2.command];
+  if (command.length !== recorded.length || command.some((a, i) => a !== recorded[i])) {
+    throw new CaptureError(
+      `${fp}: refusing to run: the fixture's source.command ${JSON.stringify(recorded)} differs from the test's COMMAND ${JSON.stringify(command)}; review the change, then update the test`
+    );
+  }
+  if (command.some((a) => a.includes(REDACTED_MARKER) || PLACEHOLDER.test(a))) {
+    throw new CaptureError(
+      `${fp}: refusing to run: the recorded command has redacted or templated arguments; re-run \`attest capture\` with the real command`
+    );
+  }
+  if (doc.world !== null && options2.world === void 0) {
+    throw new CaptureError(`${fp}: captured with a world; pass the world file the capture ran with`);
+  }
+  const env = { ...process.env, OPENAI_API_KEY: "replay-needs-no-key", ATTEST_EGRESS: "block" };
+  for (const key of OTHER_PROVIDER_KEYS) delete env[key];
+  const engine = await resolveEngine(options2.enginePath);
+  const tmp = fs2.mkdtempSync(path2.join(os2.tmpdir(), "attest-replay-"));
+  try {
+    const traceFile = path2.join(tmp, "trace.json");
+    const argv = ["replay", "--fixture", fp, "--mode", "strict", "--no-live", "--trace-out", traceFile, "--json"];
+    if (options2.world !== void 0) argv.push("--world", path2.resolve(toPath(options2.world)));
+    argv.push("--", ...command);
+    const timeoutMs = options2.timeoutMs ?? REPLAY_TIMEOUT_MS;
+    const run = await runEngine(engine, argv, {
+      cwd: options2.cwd === void 0 ? void 0 : toPath(options2.cwd),
+      env,
+      timeoutMs
+    });
+    if (run.error !== null) throw new CaptureError(`${fp}: ${run.error}`);
+    if (run.timedOut) throw new CaptureError(`${fp}: replay run exceeded ${timeoutMs}ms`);
+    checkReplay(fp, doc, run);
+    if (!fs2.existsSync(traceFile)) {
+      throw new CaptureError(`${fp}: the replay run exported no trace
+${tail(run.stderr)}`);
+    }
+    return JSON.parse(fs2.readFileSync(traceFile, "utf8"));
+  } finally {
+    fs2.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+function tail(stderr) {
+  return stderr.slice(-STDERR_TAIL);
+}
+function checkReplay(fp, fixture, run) {
+  let misses;
+  let exitCode;
+  try {
+    const result = JSON.parse(run.stdout);
+    misses = Number(result.summary.misses);
+    exitCode = Number(result.exit_code);
+    if (!Number.isInteger(misses) || !Number.isInteger(exitCode)) throw new TypeError("not integers");
+  } catch {
+    throw new CaptureError(`${fp}: replay run exited ${run.code ?? run.signal}
+${tail(run.stderr)}`);
+  }
+  if (misses > 0) throw new CaptureError(`${fp}: ${misses} request(s) matched no recording
+${tail(run.stderr)}`);
+  const recorded = fixture.source.exit_code ?? 0;
+  if (exitCode !== recorded) {
+    throw new CaptureError(`${fp}: the command exited ${exitCode}; the recording exited ${recorded}
+${tail(run.stderr)}`);
+  }
+}
+function runEngine(engine, argv, opts) {
+  return new Promise((resolve5) => {
+    const child = spawn2(engine, argv, { cwd: opts.cwd, env: opts.env, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    child.stdout.setEncoding("utf8").on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8").on("data", (chunk) => {
+      stderr += chunk;
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, opts.timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve5({ code: null, signal: null, stdout, stderr, timedOut, error: `could not start the replay run: ${err.message}` });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      resolve5({ code, signal, stdout, stderr, timedOut, error: null });
+    });
+  });
+}
 function serve(engine, args) {
   const child = spawn2(engine, args, { stdio: ["pipe", "pipe", "pipe"] });
   let stdout = "";
@@ -3335,8 +3901,8 @@ function tier(level) {
 }
 
 // src/plugins.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync } from "fs";
-import { dirname as dirname2, join as join4, relative as relative2, resolve as resolve4, isAbsolute, sep as sep2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, realpathSync } from "fs";
+import { dirname as dirname3, join as join4, relative as relative2, resolve as resolve4, isAbsolute, sep as sep2 } from "path";
 import { pathToFileURL } from "url";
 var PluginRegistry = class {
   plugins = /* @__PURE__ */ new Map();
@@ -3391,6 +3957,21 @@ async function executePluginAssertion(plugin, trace, spec, client, traceId2, ass
   );
   return result;
 }
+async function submitPluginResults(registry, client, trace, assertions) {
+  for (const assertion of assertions) {
+    if (assertion.type !== TYPE_PLUGIN) continue;
+    const pluginId = assertion.spec["plugin_id"];
+    if (typeof pluginId !== "string" || pluginId === "") continue;
+    const plugin = registry.get("assertion", pluginId);
+    if (plugin === void 0) continue;
+    if (plugin.name !== pluginId) {
+      throw new Error(
+        `Plugin registered for "${pluginId}" is named "${plugin.name}"; the engine matches submitted results by plugin name, so the two must be equal`
+      );
+    }
+    await executePluginAssertion(plugin, trace, assertion.spec, client, trace.trace_id, assertion.assertion_id);
+  }
+}
 function registerPlugin(registry, name, plugin) {
   registry.register(name, plugin);
 }
@@ -3400,14 +3981,14 @@ function isAttestPlugin(value) {
   return typeof v["name"] === "string" && typeof v["pluginType"] === "string" && typeof v["execute"] === "function";
 }
 function readJson(path5) {
-  return JSON.parse(readFileSync2(path5, "utf8"));
+  return JSON.parse(readFileSync3(path5, "utf8"));
 }
 function findInstalledPackage(projectRoot, name) {
   let dir = resolve4(projectRoot);
   for (; ; ) {
     const candidate = join4(dir, "node_modules", name);
-    if (existsSync2(join4(candidate, "package.json"))) return candidate;
-    const parent = dirname2(dir);
+    if (existsSync4(join4(candidate, "package.json"))) return candidate;
+    const parent = dirname3(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -3489,6 +4070,11 @@ async function loadPackagePlugins(registry, projectRoot = process.cwd()) {
 // src/continuous.ts
 import { EventEmitter } from "events";
 var DEFAULT_QUEUE_SIZE = 1e3;
+var DEFAULT_DISPATCH_TIMEOUT_MS = 1e4;
+var DEFAULT_DRAIN_TIMEOUT_MS = 15e3;
+var DEFAULT_STATIC_THRESHOLD = 0.8;
+var STATUS_HARD_FAIL2 = "hard_fail";
+var STATUS_DRIFT_DETECTED = "drift_detected";
 function resolveQueueSize() {
   const raw = process.env["ATTEST_CONTINUOUS_QUEUE_SIZE"];
   if (raw !== void 0 && raw !== "") {
@@ -3509,13 +4095,18 @@ var Sampler = class {
     return Math.random() < this.rate;
   }
 };
+function slackText(alert) {
+  return `[attest] drift alert \u2014 runner=${alert.runner} assertion=${alert.assertion_id} status=${alert.status} score=${alert.score} baseline_mean=${alert.baseline_mean} baseline_count=${alert.baseline_count} static_threshold=${alert.static_threshold} trace_id=${alert.trace_id}`;
+}
 var AlertDispatcher = class extends EventEmitter {
   webhookUrl;
   slackUrl;
-  constructor(webhookUrl, slackUrl) {
+  timeoutMs;
+  constructor(webhookUrl, slackUrl, timeoutMs = DEFAULT_DISPATCH_TIMEOUT_MS) {
     super();
     this.webhookUrl = webhookUrl;
     this.slackUrl = slackUrl;
+    this.timeoutMs = timeoutMs;
   }
   async dispatch(alert) {
     this.emit("alert", alert);
@@ -3524,8 +4115,7 @@ var AlertDispatcher = class extends EventEmitter {
       tasks.push(this.postJson(this.webhookUrl, alert));
     }
     if (this.slackUrl) {
-      const text = `[attest] drift alert -- type=${alert.drift_type} score=${alert.score} trace_id=${alert.trace_id}`;
-      tasks.push(this.postJson(this.slackUrl, { text }));
+      tasks.push(this.postJson(this.slackUrl, { text: slackText(alert) }));
     }
     const results = await Promise.allSettled(tasks);
     for (const result of results) {
@@ -3539,7 +4129,7 @@ var AlertDispatcher = class extends EventEmitter {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(payload),
-      signal: AbortSignal.timeout(1e4)
+      signal: AbortSignal.timeout(this.timeoutMs)
     });
     if (!response.ok) {
       throw new Error(`POST to ${url} returned ${response.status}`);
@@ -3553,21 +4143,124 @@ var ContinuousEvalRunner = class {
   dispatcher;
   queue = [];
   maxSize;
+  name;
+  drainTimeoutMs;
+  onError;
+  inFlight = /* @__PURE__ */ new Set();
+  chain = Promise.resolve();
   running = false;
   loopTimer = null;
   constructor(client, assertions, options2) {
     this.client = client;
-    this.assertions = assertions;
-    this.sampler = new Sampler(options2?.sampleRate ?? 1);
-    this.dispatcher = new AlertDispatcher(options2?.alertWebhook, options2?.alertSlackUrl);
-    this.maxSize = options2?.maxSize ?? resolveQueueSize();
+    if (typeof options2?.name !== "string" || options2.name === "") {
+      throw new Error("ContinuousEvalRunner requires options.name: it is the scope of the assertion ids");
+    }
+    const ids = new AssertionIdAssigner(options2.name);
+    this.assertions = assertions.map((a) => ({
+      ...a,
+      assertion_id: ids.next(a.type, a.spec),
+      scope_id: options2.name
+    }));
+    this.sampler = new Sampler(options2.sampleRate ?? 1);
+    this.name = options2.name;
+    this.onError = options2.onError;
+    this.drainTimeoutMs = options2.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
+    this.dispatcher = new AlertDispatcher(
+      options2.alertWebhook,
+      options2.alertSlackUrl,
+      options2.dispatchTimeoutMs ?? DEFAULT_DISPATCH_TIMEOUT_MS
+    );
+    this.dispatcher.on("alertError", (error) => this.reportError(error));
+    this.maxSize = options2.maxSize ?? resolveQueueSize();
   }
   get alertEmitter() {
     return this.dispatcher;
   }
+  /** Runs `fn` after every previously queued evaluation, so evaluate → query_drift pairs never interleave. */
+  serialize(fn) {
+    const run = this.chain.then(fn, fn);
+    this.chain = run.catch(() => void 0);
+    return run;
+  }
+  /** Surfaces an error to the log and `onError` without ever throwing or leaving a rejected promise. */
+  reportError(error) {
+    try {
+      console.error(`attest continuous-eval runner ${JSON.stringify(this.name)}:`, error);
+    } catch {
+    }
+    if (this.onError === void 0) return;
+    try {
+      const returned = this.onError(error);
+      if (returned instanceof Promise) {
+        returned.catch((observerError) => this.logObserverFailure(observerError));
+      }
+    } catch (observerError) {
+      this.logObserverFailure(observerError);
+    }
+  }
+  logObserverFailure(observerError) {
+    try {
+      console.error(`attest continuous-eval runner ${JSON.stringify(this.name)}: onError callback failed:`, observerError);
+    } catch {
+    }
+  }
+  emitError(error) {
+    try {
+      this.dispatcher.emit("alertError", error);
+    } catch (listenerError) {
+      this.logObserverFailure(listenerError);
+    }
+  }
   async evaluateTrace(trace) {
     if (!this.sampler.shouldSample()) return null;
-    return this.client.evaluateBatch(trace, this.assertions);
+    const work = this.serialize(() => this.evaluateAndAlert(trace));
+    this.inFlight.add(work);
+    try {
+      return await work;
+    } finally {
+      this.inFlight.delete(work);
+    }
+  }
+  async evaluateAndAlert(trace) {
+    const result = await this.client.evaluateBatch(trace, this.assertions);
+    for (const r of result.results) {
+      await this.alertIfNeeded(trace, r);
+    }
+    return result;
+  }
+  staticThresholdFor(assertionId2) {
+    const spec = this.assertions.find((a) => a.assertion_id === assertionId2)?.spec;
+    const threshold = spec?.["threshold"];
+    return typeof threshold === "number" && threshold > 0 ? threshold : DEFAULT_STATIC_THRESHOLD;
+  }
+  async alertIfNeeded(trace, result) {
+    if (result.status === "not_evaluated") return;
+    const staticThreshold = this.staticThresholdFor(result.assertion_id);
+    let report;
+    try {
+      report = await this.client.queryDrift(result.assertion_id, void 0, { staticThreshold });
+    } catch (error) {
+      this.emitError(error);
+    }
+    const hardFailed = result.status === STATUS_HARD_FAIL2;
+    const drifted = report?.status === STATUS_DRIFT_DETECTED;
+    if (!drifted && !hardFailed) return;
+    const alert = {
+      runner: this.name,
+      assertion_id: result.assertion_id,
+      status: hardFailed ? STATUS_HARD_FAIL2 : STATUS_DRIFT_DETECTED,
+      result_status: result.status,
+      score: typeof result.score === "number" ? result.score : null,
+      baseline_mean: report?.mean ?? null,
+      baseline_count: report?.count ?? null,
+      static_threshold: staticThreshold,
+      trace_id: trace.trace_id ?? null
+    };
+    try {
+      await this.dispatcher.dispatch(alert);
+    } catch (error) {
+      this.emitError(error);
+    }
   }
   submit(trace) {
     if (this.queue.length >= this.maxSize) {
@@ -3581,12 +4274,52 @@ var ContinuousEvalRunner = class {
     this.running = true;
     this.scheduleNext();
   }
-  stop() {
+  /**
+   * Stops the loop, then processes the traces already queued and waits for in-flight evaluations
+   * and dispatches, all bounded by `drainTimeoutMs`. At the bound the whole remaining queue is
+   * discarded (nothing is evaluated after the timeout and nothing is left for a restart), the
+   * evaluation already in flight is left to finish, and the timeout with the number of discarded
+   * traces is reported through `onError`.
+   */
+  async stop() {
     this.running = false;
     if (this.loopTimer !== null) {
       clearTimeout(this.loopTimer);
       this.loopTimer = null;
     }
+    if (this.inFlight.size === 0 && this.queue.length === 0) return;
+    let expired = false;
+    let discarded = 0;
+    let timer;
+    const bound = new Promise((resolve5) => {
+      timer = setTimeout(() => {
+        expired = true;
+        discarded = this.queue.splice(0).length;
+        resolve5("timeout");
+      }, this.drainTimeoutMs);
+    });
+    const drained = this.drainQueue(() => expired).then(() => "drained");
+    const outcome = await Promise.race([drained, bound]);
+    clearTimeout(timer);
+    if (outcome === "timeout") {
+      this.emitError(
+        new Error(
+          `stop() gave up after ${this.drainTimeoutMs} ms with ${this.inFlight.size} evaluation(s) in flight; discarded ${discarded} queued trace(s) not evaluated`
+        )
+      );
+    }
+  }
+  async drainQueue(expired) {
+    while (!expired()) {
+      const trace = this.queue.shift();
+      if (trace === void 0) break;
+      try {
+        await this.evaluateTrace(trace);
+      } catch (error) {
+        this.reportError(error);
+      }
+    }
+    await Promise.allSettled([...this.inFlight]);
   }
   get queueLength() {
     return this.queue.length;
@@ -3596,22 +4329,29 @@ var ContinuousEvalRunner = class {
   }
   scheduleNext() {
     if (!this.running) return;
-    this.loopTimer = setTimeout(async () => {
+    this.loopTimer = setTimeout(() => {
+      void this.tick();
+    }, this.queue.length > 0 ? 0 : 100);
+  }
+  async tick() {
+    try {
       if (!this.running) return;
       const trace = this.queue.shift();
       if (trace !== void 0) {
         try {
           await this.evaluateTrace(trace);
-        } catch {
+        } catch (error) {
+          this.reportError(error);
         }
       }
+    } finally {
       this.scheduleNext();
-    }, this.queue.length > 0 ? 0 : 100);
+    }
   }
 };
 
 // src/calibration.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function computeAgreement(pairs, threshold) {
   if (pairs.length === 0) {
     throw new Error("no labeled pairs available");
@@ -3756,7 +4496,7 @@ function loadLabelsJSONL(text) {
   return out;
 }
 function promptHash(text) {
-  return createHash2("sha256").update(text).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(text).digest("hex").slice(0, 16);
 }
 function parseFloatStrict(raw) {
   const trimmed = raw.trim();
@@ -4046,44 +4786,116 @@ var ManualAdapter = class {
   }
 };
 
+// src/adapters/provider-trace.ts
+function latency(options2) {
+  if (options2?.latencyMs !== void 0) return options2.latencyMs;
+  if (options2?.startedAtMs !== void 0 && options2.endedAtMs !== void 0) {
+    return options2.endedAtMs - options2.startedAtMs;
+  }
+  return void 0;
+}
+function buildProviderTrace(agentId2, call2, options2, input, output) {
+  const builder = new TraceBuilder(agentId2);
+  if (input !== void 0) builder.setInput(input);
+  const now = Date.now();
+  const args = {};
+  if (call2.model !== void 0) args.model = call2.model;
+  const result = { completion: call2.completion };
+  if (call2.refusal) result.refusal = call2.refusal;
+  if (call2.totalTokens !== void 0) result.tokens = call2.totalTokens;
+  if (call2.inputTokens !== void 0) result.input_tokens = call2.inputTokens;
+  if (call2.outputTokens !== void 0) result.output_tokens = call2.outputTokens;
+  builder.addStep({
+    type: STEP_LLM_CALL,
+    name: "completion",
+    args,
+    result,
+    started_at_ms: options2?.startedAtMs ?? now,
+    ended_at_ms: options2?.endedAtMs ?? now
+  });
+  for (const tc of call2.toolCalls) {
+    builder.addToolCall(tc.name, { args: tc.args });
+  }
+  builder.setOutput(output);
+  builder.setMetadata({
+    total_tokens: call2.totalTokens,
+    cost_usd: options2?.costUsd,
+    latency_ms: latency(options2),
+    model: call2.model
+  });
+  return builder.build();
+}
+
 // src/adapters/openai.ts
+function parseArguments(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { raw_arguments: raw };
+  }
+  if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  return { raw_arguments: raw };
+}
+function isResponses(response) {
+  return response.object === "response";
+}
+function fromResponses(response) {
+  const texts = [];
+  const refusals = [];
+  const toolCalls = [];
+  for (const item of response.output) {
+    if (item.type === "message") {
+      for (const part of item.content) {
+        if (part.type === "output_text") texts.push(part.text);
+        else if (part.type === "refusal") refusals.push(part.refusal);
+      }
+    } else if (item.type === "function_call") {
+      const call2 = item;
+      toolCalls.push({ name: call2.name, args: parseArguments(call2.arguments) });
+    }
+  }
+  const refusal = refusals.join("") || void 0;
+  return {
+    model: response.model,
+    completion: texts.join("") || refusal || "",
+    refusal,
+    totalTokens: response.usage?.total_tokens,
+    inputTokens: response.usage?.input_tokens,
+    outputTokens: response.usage?.output_tokens,
+    toolCalls
+  };
+}
+function fromChat(response) {
+  const message = response.choices[0].message;
+  const refusal = message.refusal || void 0;
+  return {
+    model: response.model,
+    completion: message.content || refusal || "",
+    refusal,
+    totalTokens: response.usage?.total_tokens,
+    inputTokens: response.usage?.prompt_tokens,
+    outputTokens: response.usage?.completion_tokens,
+    toolCalls: (message.tool_calls ?? []).map((tc) => ({
+      name: tc.function.name,
+      args: parseArguments(tc.function.arguments)
+    }))
+  };
+}
 var OpenAIAdapter = class {
   agentId;
   constructor(agentId2) {
     this.agentId = agentId2;
   }
   traceFromResponse(response, options2) {
-    const builder = new TraceBuilder(this.agentId);
-    if (options2?.inputMessages) {
-      builder.setInput({ messages: options2.inputMessages });
-    }
-    const message = response.choices[0].message;
-    const completionText = message.content ?? "";
-    const stepArgs = {};
-    if (response.model !== void 0) stepArgs.model = response.model;
-    const stepResult = { completion: completionText };
-    if (response.usage?.total_tokens !== void 0) {
-      stepResult.tokens = response.usage.total_tokens;
-    }
-    builder.addLlmCall("completion", { args: stepArgs, result: stepResult });
-    if (message.tool_calls) {
-      for (const tc of message.tool_calls) {
-        builder.addToolCall(tc.function.name, {
-          args: { arguments: tc.function.arguments }
-        });
-      }
-    }
-    builder.setOutput({
-      message: completionText,
+    const call2 = isResponses(response) ? fromResponses(response) : fromChat(response);
+    const input = options2?.inputMessages ? { messages: options2.inputMessages } : void 0;
+    return buildProviderTrace(this.agentId, call2, options2, input, {
+      message: call2.completion,
       structured: options2?.structuredOutput ?? {}
     });
-    builder.setMetadata({
-      total_tokens: response.usage?.total_tokens,
-      cost_usd: options2?.costUsd,
-      latency_ms: options2?.latencyMs,
-      model: response.model
-    });
-    return builder.build();
   }
 };
 
@@ -4094,73 +4906,79 @@ var AnthropicAdapter = class {
     this.agentId = agentId2;
   }
   traceFromResponse(response, options2) {
-    const builder = new TraceBuilder(this.agentId);
-    if (options2?.inputMessages) {
-      builder.setInput({ messages: options2.inputMessages });
-    }
-    const completionParts = [];
+    const texts = [];
+    const toolCalls = [];
     for (const block of response.content) {
       if (block.type === "text") {
-        completionParts.push(block.text);
-      } else if (block.type === "tool_use") {
-        builder.addToolCall(block.name, {
-          args: block.input
-        });
+        texts.push(block.text);
+      } else if (block.type === "tool_use" || block.type === "server_tool_use") {
+        const use = block;
+        toolCalls.push({ name: use.name, args: use.input });
       }
     }
-    const completionText = completionParts.join("\n");
-    const stepArgs = {};
-    if (response.model !== void 0) stepArgs.model = response.model;
-    builder.addLlmCall("completion", { args: stepArgs, result: { completion: completionText } });
-    builder.setOutput({ message: completionText });
-    let totalTokens;
-    if (response.usage) {
-      totalTokens = response.usage.input_tokens + response.usage.output_tokens;
-    }
-    builder.setMetadata({
-      total_tokens: totalTokens,
-      cost_usd: options2?.costUsd,
-      latency_ms: options2?.latencyMs,
-      model: response.model
-    });
-    return builder.build();
+    const completion = texts.join("\n");
+    const usage = response.usage;
+    const input = options2?.inputMessages ? { messages: options2.inputMessages } : void 0;
+    return buildProviderTrace(
+      this.agentId,
+      {
+        model: response.model,
+        completion,
+        totalTokens: usage ? usage.input_tokens + usage.output_tokens : void 0,
+        inputTokens: usage?.input_tokens,
+        outputTokens: usage?.output_tokens,
+        toolCalls
+      },
+      options2,
+      input,
+      { message: completion }
+    );
   }
 };
 
 // src/adapters/gemini.ts
+function totalTokens(usage) {
+  if (usage === void 0) return void 0;
+  if (usage.totalTokenCount !== void 0) return usage.totalTokenCount;
+  if (usage.promptTokenCount !== void 0 && usage.candidatesTokenCount !== void 0) {
+    return usage.promptTokenCount + usage.candidatesTokenCount;
+  }
+  return usage.promptTokenCount;
+}
+function geminiInput(options2) {
+  const messages = options2?.inputMessages;
+  if (messages && messages.length > 0) {
+    const first = messages[0];
+    if (messages.length === 1 && typeof first.content === "string") return { text: first.content };
+    return { messages };
+  }
+  if (options2?.inputText) return { text: options2.inputText };
+  return void 0;
+}
 var GeminiAdapter = class {
   agentId;
   constructor(agentId2) {
     this.agentId = agentId2;
   }
   traceFromResponse(response, options2) {
-    const builder = new TraceBuilder(this.agentId);
-    if (options2?.inputText) {
-      builder.setInput({ text: options2.inputText });
-    }
-    let completionText = "";
-    if (response.text != null) {
-      completionText = response.text;
-    } else if (response.candidates && response.candidates.length > 0) {
-      completionText = response.candidates[0].content.parts.filter((p) => p.text != null).map((p) => p.text).join("");
-    }
-    if (response.candidates && response.candidates.length > 0) {
-      for (const part of response.candidates[0].content.parts) {
-        if (part.functionCall) {
-          builder.addToolCall(part.functionCall.name, {
-            args: part.functionCall.args ?? {}
-          });
-        }
-      }
-    }
-    builder.addLlmCall("completion", { result: { completion: completionText } });
-    builder.setOutput({ message: completionText });
-    builder.setMetadata({
-      cost_usd: options2?.costUsd,
-      latency_ms: options2?.latencyMs,
-      model: options2?.model
-    });
-    return builder.build();
+    const parts = response.candidates?.[0]?.content.parts ?? [];
+    const completion = response.text ?? parts.filter((p) => p.text && !p.thought).map((p) => p.text).join("");
+    const toolCalls = parts.filter((p) => p.functionCall).map((p) => ({ name: p.functionCall.name, args: p.functionCall.args ?? {} }));
+    const usage = response.usageMetadata;
+    return buildProviderTrace(
+      this.agentId,
+      {
+        model: options2?.model ?? response.modelVersion,
+        completion,
+        totalTokens: totalTokens(usage),
+        inputTokens: usage?.promptTokenCount,
+        outputTokens: usage?.candidatesTokenCount,
+        toolCalls
+      },
+      options2,
+      geminiInput(options2),
+      { message: completion }
+    );
   }
 };
 
@@ -4171,26 +4989,26 @@ var OllamaAdapter = class {
     this.agentId = agentId2;
   }
   traceFromResponse(response, options2) {
-    const builder = new TraceBuilder(this.agentId);
-    if (options2?.inputMessages) {
-      builder.setInput({ messages: options2.inputMessages });
-    }
-    const completionText = response.message?.content ?? "";
-    builder.addLlmCall("completion", {
-      args: { model: response.model ?? "" },
-      result: { completion: completionText }
-    });
-    builder.setOutput({ message: completionText });
-    let totalTokens;
-    if (response.eval_count !== void 0 && response.prompt_eval_count !== void 0) {
-      totalTokens = response.eval_count + response.prompt_eval_count;
-    }
-    builder.setMetadata({
-      total_tokens: totalTokens,
-      latency_ms: options2?.latencyMs,
-      model: response.model
-    });
-    return builder.build();
+    const completion = response.message?.content ?? "";
+    const counted = response.eval_count !== void 0 && response.prompt_eval_count !== void 0;
+    const input = options2?.inputMessages ? { messages: options2.inputMessages } : void 0;
+    return buildProviderTrace(
+      this.agentId,
+      {
+        model: response.model,
+        completion,
+        totalTokens: counted ? response.eval_count + response.prompt_eval_count : void 0,
+        inputTokens: counted ? response.prompt_eval_count : void 0,
+        outputTokens: counted ? response.eval_count : void 0,
+        toolCalls: (response.message?.tool_calls ?? []).map((tc) => ({
+          name: tc.function?.name ?? "",
+          args: tc.function?.arguments ?? {}
+        }))
+      },
+      options2,
+      input,
+      { message: completion }
+    );
   }
 };
 
@@ -4339,97 +5157,239 @@ function spansToOtlp(spans) {
 }
 
 // src/adapters/langchain.ts
-var LangChainAdapter = class {
+import { createRequire } from "module";
+function resolveBaseCallbackHandler() {
+  const load = createRequire(typeof __filename === "string" ? __filename : import.meta.url);
+  try {
+    const mod = load("@langchain/core/callbacks/base");
+    return mod.BaseCallbackHandler;
+  } catch (cause) {
+    if (cause.code !== "MODULE_NOT_FOUND") throw cause;
+    return class MissingLangChain {
+      constructor() {
+        throw new Error(
+          "LangChainAdapter requires @langchain/core: install it with `npm install @langchain/core`."
+        );
+      }
+    };
+  }
+}
+var BaseCallbackHandler = resolveBaseCallbackHandler();
+function isValues(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasContent(value) {
+  return isValues(value) && "content" in value;
+}
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((block) => {
+      if (typeof block === "string") return block;
+      if (isValues(block) && block.type === "text") return String(block.text ?? "");
+      return "";
+    }).join("");
+  }
+  return String(content);
+}
+function firstTruthy(values, keys) {
+  for (const key of keys) if (values[key]) return values[key];
+  return void 0;
+}
+function textOf(value) {
+  if (typeof value === "string") return value;
+  if (hasContent(value)) return messageText(value.content);
+  return value ? String(value) : "";
+}
+function modelNameOf(extraParams) {
+  if (extraParams === void 0) return void 0;
+  const params = isValues(extraParams.invocation_params) ? extraParams.invocation_params : extraParams;
+  const name = params.model_name ?? params.model ?? params.modelName;
+  return typeof name === "string" && name ? name : void 0;
+}
+function toolNameOf(serialized, runName) {
+  if (runName) return runName;
+  if (isValues(serialized)) {
+    if (typeof serialized.name === "string" && serialized.name) return serialized.name;
+    if (Array.isArray(serialized.id) && serialized.id.length > 0) return String(serialized.id.at(-1));
+  }
+  return "unknown_tool";
+}
+function toolInputOf(input) {
+  try {
+    const parsed = JSON.parse(input);
+    if (isValues(parsed)) return parsed;
+  } catch {
+  }
+  return { input };
+}
+var LangChainAdapter = class extends BaseCallbackHandler {
+  name = "attest_langchain_adapter";
   agentId;
-  llmCalls = [];
-  toolCalls = [];
-  chainOutput = "";
-  startTime = 0;
+  input;
+  output;
+  steps = [];
+  llmStarts = /* @__PURE__ */ new Map();
+  toolStarts = /* @__PURE__ */ new Map();
+  totalTokens = 0;
+  model;
+  startedAtMs;
+  endedAtMs;
   constructor(agentId2) {
+    super();
     this.agentId = agentId2;
+    this.awaitHandlers = true;
+    this.raiseError = false;
   }
-  /**
-   * Reset accumulated state for a new trace capture session.
-   */
-  reset() {
-    this.llmCalls.length = 0;
-    this.toolCalls.length = 0;
-    this.chainOutput = "";
-    this.startTime = 0;
+  /** Handlers are shared by the callback manager, never cloned: a clone would lose the capture. */
+  copy() {
+    return this;
   }
-  /**
-   * Call this when a chain starts (maps to `handleChainStart`).
-   */
-  handleChainStart() {
-    if (this.startTime === 0) {
-      this.startTime = Date.now();
+  /** Reset accumulated state for a new capture session. */
+  reset() {
+    this.input = void 0;
+    this.output = void 0;
+    this.steps = [];
+    this.llmStarts.clear();
+    this.toolStarts.clear();
+    this.totalTokens = 0;
+    this.model = void 0;
+    this.startedAtMs = void 0;
+    this.endedAtMs = void 0;
+  }
+  now() {
+    return Date.now();
+  }
+  handleChainStart(_chain, inputs, _runId, parentRunId) {
+    if (parentRunId !== void 0) return;
+    this.startedAtMs = this.now();
+    if (!isValues(inputs)) return;
+    const message = firstTruthy(inputs, ["input", "messages", "query"]) ?? "";
+    if (typeof message === "string") {
+      this.input = message;
+    } else if (Array.isArray(message) && message.length > 0) {
+      const first = message[0];
+      this.input = hasContent(first) ? messageText(first.content) : String(first);
+    } else {
+      this.input = message ? String(message) : "";
     }
   }
-  /**
-   * Call this when an LLM call completes (maps to `handleLLMEnd`).
-   */
-  handleLLMEnd(output) {
-    const text = output.generations[0]?.[0]?.text ?? "";
-    const tokens = output.llmOutput?.["tokenUsage"];
-    const model = output.llmOutput?.["modelName"];
-    this.llmCalls.push({
-      name: "completion",
-      text,
-      tokens: tokens?.totalTokens,
-      model
+  handleChainEnd(outputs, _runId, parentRunId) {
+    if (parentRunId !== void 0) return;
+    this.endedAtMs = this.now();
+    if (!isValues(outputs)) return;
+    const messages = outputs.messages;
+    if (Array.isArray(messages) && messages.length > 0) {
+      const last = messages[messages.length - 1];
+      if (hasContent(last)) {
+        this.output = messageText(last.content);
+        return;
+      }
+    }
+    this.output = textOf(firstTruthy(outputs, ["output", "result", "text"]));
+  }
+  handleChatModelStart(_llm, _messages, runId, _parentRunId, extraParams) {
+    this.llmStarts.set(runId, { modelName: modelNameOf(extraParams), startedAtMs: this.now() });
+  }
+  handleLLMStart(_llm, _prompts, runId, _parentRunId, extraParams) {
+    this.llmStarts.set(runId, { modelName: modelNameOf(extraParams), startedAtMs: this.now() });
+  }
+  handleLLMEnd(output, runId) {
+    const start3 = this.llmStarts.get(runId);
+    this.llmStarts.delete(runId);
+    const endedAtMs = this.now();
+    let modelName = start3?.modelName;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let total = 0;
+    const usage = output.generations.flat().find((g) => g.message?.usage_metadata)?.message?.usage_metadata;
+    if (usage) {
+      inputTokens = usage.input_tokens || 0;
+      outputTokens = usage.output_tokens || 0;
+      total = usage.total_tokens || inputTokens + outputTokens;
+    }
+    const llmOutput = output.llmOutput;
+    if (llmOutput) {
+      if (!usage) {
+        const tokenUsage = llmOutput.tokenUsage ?? llmOutput.token_usage ?? {};
+        inputTokens = Number(tokenUsage.promptTokens ?? tokenUsage.prompt_tokens ?? 0);
+        outputTokens = Number(tokenUsage.completionTokens ?? tokenUsage.completion_tokens ?? 0);
+        total = inputTokens + outputTokens;
+      }
+      const reported = llmOutput.model_name ?? llmOutput.modelName;
+      if (modelName === void 0 && typeof reported === "string") modelName = reported;
+    }
+    this.totalTokens += total;
+    if (modelName && this.model === void 0) this.model = modelName;
+    const args = {};
+    if (modelName) args.model = modelName;
+    const result = {};
+    const completion = output.generations[0]?.[0]?.text;
+    if (completion) result.completion = completion;
+    if (total) result.tokens = total;
+    if (inputTokens) result.input_tokens = inputTokens;
+    if (outputTokens) result.output_tokens = outputTokens;
+    this.steps.push(this.step(STEP_LLM_CALL, modelName || "llm", args, result, start3?.startedAtMs, endedAtMs));
+  }
+  handleToolStart(tool, input, runId, _parentRunId, _tags, _metadata, runName) {
+    this.toolStarts.set(runId, {
+      name: toolNameOf(tool, runName),
+      input: toolInputOf(input),
+      startedAtMs: this.now()
     });
   }
-  /**
-   * Call this when a tool call completes (maps to `handleToolEnd`).
-   */
-  handleToolEnd(output, metadata) {
-    this.toolCalls.push({
-      name: metadata?.name ?? "unknown_tool",
-      output
-    });
+  handleToolEnd(output, runId) {
+    const text = hasContent(output) ? messageText(output.content) : String(output);
+    const isToolMessage = isValues(output) && typeof output.tool_call_id === "string";
+    const toolName = isToolMessage && typeof output.name === "string" && output.name ? output.name : void 0;
+    this.finishTool(runId, { output: text }, toolName);
+  }
+  handleToolError(error, runId) {
+    const message = error instanceof Error ? error.message : String(error);
+    this.finishTool(runId, { error: message }, void 0);
+  }
+  finishTool(runId, result, endName) {
+    const start3 = this.toolStarts.get(runId);
+    this.toolStarts.delete(runId);
+    this.steps.push(
+      this.step(
+        STEP_TOOL_CALL,
+        endName ?? start3?.name ?? "unknown_tool",
+        start3?.input ?? {},
+        result,
+        start3?.startedAtMs,
+        this.now()
+      )
+    );
   }
-  /**
-   * Call this when a chain completes (maps to `handleChainEnd`).
-   */
-  handleChainEnd(output) {
-    const text = output["output"] ?? output["text"] ?? output["result"];
-    if (typeof text === "string") {
-      this.chainOutput = text;
-    }
+  step(type, name, args, result, startedAtMs, endedAtMs) {
+    return {
+      type,
+      name,
+      args,
+      result,
+      metadata: startedAtMs === void 0 ? {} : { duration_ms: endedAtMs - startedAtMs },
+      started_at_ms: startedAtMs,
+      ended_at_ms: endedAtMs,
+      agent_id: this.agentId
+    };
   }
   /**
-   * Build a Trace from accumulated callback events.
+   * Build a Trace from the captured callback events.
    *
-   * @param options.costUsd - Total cost override.
+   * @param options.costUsd - Total cost.
    * @param options.model - Model name override.
-   * @returns A finalized Trace object.
    */
   buildTrace(options2) {
     const builder = new TraceBuilder(this.agentId);
-    const latencyMs = this.startTime > 0 ? Date.now() - this.startTime : void 0;
-    let totalTokens;
-    for (const llm of this.llmCalls) {
-      const args = {};
-      if (llm.model ?? options2?.model) args.model = llm.model ?? options2?.model;
-      const result = { completion: llm.text };
-      if (llm.tokens !== void 0) {
-        result.tokens = llm.tokens;
-        totalTokens = (totalTokens ?? 0) + llm.tokens;
-      }
-      builder.addLlmCall(llm.name, { args, result });
-    }
-    for (const tool of this.toolCalls) {
-      builder.addToolCall(tool.name, {
-        result: { output: tool.output }
-      });
-    }
-    const outputMessage = this.chainOutput || (this.llmCalls.length > 0 ? this.llmCalls[this.llmCalls.length - 1].text : "");
-    builder.setOutput({ message: outputMessage });
+    if (this.input) builder.setInput({ message: this.input });
+    for (const step of this.steps) builder.addStep(step);
+    builder.setOutput({ message: this.output ?? "" });
     builder.setMetadata({
-      total_tokens: totalTokens,
+      total_tokens: this.totalTokens > 0 ? this.totalTokens : void 0,
       cost_usd: options2?.costUsd,
-      latency_ms: latencyMs,
-      model: options2?.model ?? this.llmCalls[0]?.model
+      latency_ms: this.startedAtMs !== void 0 && this.endedAtMs !== void 0 ? this.endedAtMs - this.startedAtMs : void 0,
+      model: options2?.model ?? this.model
     });
     return builder.build();
   }
@@ -4440,6 +5400,7 @@ export {
   AgentResult,
   AlertDispatcher,
   AnthropicAdapter,
+  AssertionIdAssigner,
   AttestClient,
   CONFUSED_USER,
   COOPERATIVE_USER,
@@ -4459,6 +5420,7 @@ export {
   FRIENDLY_USER,
   FailureClass,
   GeminiAdapter,
+  ID_SCHEME,
   LangChainAdapter,
   ManualAdapter,
   MockToolRegistry,
@@ -4475,7 +5437,9 @@ export {
   ProtocolError,
   REASON_BUDGET_EXHAUSTED,
   REASON_JUDGE_ABSTAINED,
+  REASON_JUDGE_MALFORMED,
   REASON_MISSING_EVIDENCE,
+  REASON_PROVIDER_AUTH,
   REASON_PROVIDER_NOT_CONFIGURED,
   REASON_PROVIDER_UNAVAILABLE,
   REASON_REPLAY_MISS,
@@ -4517,7 +5481,10 @@ export {
   agent,
   agentId,
   assertionId,
+  assertionIdOf,
   attestExpect,
+  canonicalIdInput,
+  canonicalSpec,
   computeAgreement,
   config,
   decodeResponse,
@@ -4554,13 +5521,16 @@ export {
   renderVerdictDiagnostics,
   renderVitest,
   repeat,
+  replayRun,
   requireSimulationCapability,
   resetConfig,
   resolveMode,
   scenario,
+  setChainObserver,
   simulationEnvEnabled,
   startReplay,
   startWorld,
+  submitPluginResults,
   sumUsage,
   testPathFor,
   tier,