@attest-ai/core 1.0.1 → 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,13 +222,13 @@ function extractId(response) {
 }
 
 // src/version.ts
-var VERSION = "1.0.1";
-var ENGINE_VERSION = "1.0.1";
+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/config.ts
@@ -345,6 +348,7 @@ 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"];
@@ -352,10 +356,15 @@ function resolveTimeoutMs(override) {
     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}'`
+        `ATTEST_ENGINE_TIMEOUT must be a positive number of seconds, got: '${env}'`
       );
     }
-    return parsed;
+    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 DEFAULT_TIMEOUT_MS;
 }
@@ -430,10 +439,10 @@ var AttestClient = class {
     rl.on("line", this.lineHandler);
     rl.on("close", () => {
       if (this.attachedReader !== rl) return;
-      const tail = this.engine.stderrTail ?? "";
+      const tail2 = this.engine.stderrTail ?? "";
       this.failAll(
-        new Error(tail === "" ? "Engine closed stdout." : `Engine closed stdout. stderr:
-${tail}`)
+        new Error(tail2 === "" ? "Engine closed stdout." : `Engine closed stdout. stderr:
+${tail2}`)
       );
       this.readerActive = false;
       this.attachedReader = null;
@@ -583,9 +592,9 @@ ${tail}`)
     }
     const resolvedTimeout = resolveTimeoutMs(timeoutMs);
     if (this.engine.isRunning === false) {
-      const tail = this.engine.stderrTail ?? "";
-      throw new Error(`Engine process is not running.${tail === "" ? "" : ` stderr:
-${tail}`}`);
+      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) {
@@ -627,10 +636,10 @@ ${tail}`}`);
   }
   /** A failed pipe write names the engine's stderr tail; the original error stays as `cause` and `code`. */
   describeWriteError(err) {
-    const tail = this.engine.stderrTail ?? "";
+    const tail2 = this.engine.stderrTail ?? "";
     const wrapped = new Error(
-      `Failed to write to the engine: ${err.message}.${tail === "" ? "" : ` stderr:
-${tail}`}`,
+      `Failed to write to the engine: ${err.message}.${tail2 === "" ? "" : ` stderr:
+${tail2}`}`,
       { cause: err }
     );
     return Object.assign(wrapped, { code: err.code });
@@ -726,7 +735,11 @@ ${tail}`}`,
     }
     const raw = await this.sendRequest(
       "query_drift",
-      { assertion_id: assertionId2, window_size: windowSize },
+      {
+        assertion_id: assertionId2,
+        window_size: windowSize,
+        ...options2?.staticThreshold !== void 0 ? { static_threshold: options2.staticThreshold } : {}
+      },
       options2?.timeout
     );
     return raw.report;
@@ -789,14 +802,18 @@ function requireSimulationCapability(init) {
 
 // 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";
+import { fileURLToPath } from "url";
 var RELEASE_BASE = `https://github.com/attest-framework/attest/releases/download/v${ENGINE_VERSION}`;
-var CHECKSUMS_URL = `${RELEASE_BASE}/checksums-sha256.txt`;
+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);
 }
@@ -829,73 +846,131 @@ function cachedEnginePath() {
   const binPath = path.join(versionedBinDir(), binaryFilename());
   return fs.statSync(binPath, { throwIfNoEntry: false })?.isFile() ? binPath : null;
 }
-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 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 checksums;
+  return dir;
 }
-function httpsGet(url, redirectCount = 0) {
-  if (redirectCount > MAX_REDIRECTS) {
-    return Promise.reject(
-      new Error(`Too many redirects (>${MAX_REDIRECTS}) following ${url}`)
+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) => {
-    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));
+    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 (status < 200 || status >= 300) {
-        res.resume();
-        reject(new Error(`HTTP ${status} fetching ${url}`));
+      if (parsed.protocol !== "https:") {
+        finish(new Error(`Refusing to download over a non-https URL: ${target}`));
         return;
       }
-      const chunks = [];
-      res.on("data", (chunk) => chunks.push(chunk));
-      res.on("end", () => resolve5(Buffer.concat(chunks)));
-      res.on("error", reject);
-    }).on("error", reject);
+      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() {
+async function downloadEngine(options2 = {}) {
   const key = platformKey();
   const filename = `attest-engine-${key}${os.platform() === "win32" ? ".exe" : ""}`;
-  const binaryUrl = `${RELEASE_BASE}/${filename}`;
+  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}...
 `);
-  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(", ")}`
-    );
+  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}`);
   }
-  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.`
+      `${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.
@@ -976,7 +1051,7 @@ function onPath() {
   return null;
 }
 function requireFile(enginePath, label) {
-  if (!existsSync(enginePath) || !statSync2(enginePath).isFile()) {
+  if (!existsSync2(enginePath) || !statSync2(enginePath).isFile()) {
     throw new Error(`${label}=${enginePath} does not exist or is not a file.`);
   }
 }
@@ -1800,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];
@@ -2743,11 +2832,101 @@ function attestExpect(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)}`);
+  }
+}
+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 {
@@ -2760,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);
@@ -2884,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) {
@@ -2894,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 = [
@@ -2906,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]> = [");
@@ -2946,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" });
@@ -2965,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 = "";
@@ -3557,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();
@@ -3613,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);
 }
@@ -3622,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;
   }
@@ -3711,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 !== "") {
@@ -3731,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);
@@ -3746,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) {
@@ -3761,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}`);
@@ -3775,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) {
@@ -3803,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;
@@ -3818,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");
@@ -3978,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();
@@ -4268,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();
   }
 };
 
@@ -4316,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 }
+    );
   }
 };
 
@@ -4393,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 }
+    );
   }
 };
 
@@ -4561,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();
   }
@@ -4662,6 +5400,7 @@ export {
   AgentResult,
   AlertDispatcher,
   AnthropicAdapter,
+  AssertionIdAssigner,
   AttestClient,
   CONFUSED_USER,
   COOPERATIVE_USER,
@@ -4681,6 +5420,7 @@ export {
   FRIENDLY_USER,
   FailureClass,
   GeminiAdapter,
+  ID_SCHEME,
   LangChainAdapter,
   ManualAdapter,
   MockToolRegistry,
@@ -4697,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,
@@ -4739,7 +5481,10 @@ export {
   agent,
   agentId,
   assertionId,
+  assertionIdOf,
   attestExpect,
+  canonicalIdInput,
+  canonicalSpec,
   computeAgreement,
   config,
   decodeResponse,
@@ -4776,13 +5521,16 @@ export {
   renderVerdictDiagnostics,
   renderVitest,
   repeat,
+  replayRun,
   requireSimulationCapability,
   resetConfig,
   resolveMode,
   scenario,
+  setChainObserver,
   simulationEnvEnabled,
   startReplay,
   startWorld,
+  submitPluginResults,
   sumUsage,
   testPathFor,
   tier,