@plune-ai/cli 0.2.0

package/dist/cli.cjs

@@ -0,0 +1,2721 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.15_t_55a87a10d51c31d069b35a93bf4e9619/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl, importMetaUrl;
+var init_cjs_shims = __esm({
+  "node_modules/.pnpm/tsup@8.5.1_postcss@8.5.15_t_55a87a10d51c31d069b35a93bf4e9619/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+  }
+});
+
+// src/cli/env.ts
+var env_exports = {};
+__export(env_exports, {
+  loadEnv: () => loadEnv
+});
+function loadEnv(configDir) {
+  (0, import_dotenv.config)({ path: path.join(configDir, ".env"), override: false });
+}
+var import_dotenv, path;
+var init_env = __esm({
+  "src/cli/env.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_dotenv = require("dotenv");
+    path = __toESM(require("path"), 1);
+  }
+});
+
+// src/config/env-overrides.ts
+function applyEnvOverrides(config, env) {
+  const result = structuredClone(config);
+  if (env["PLUNE_PROVIDER"] !== void 0) {
+    result.provider.type = env["PLUNE_PROVIDER"];
+  }
+  if (env["PLUNE_MODEL"] !== void 0) {
+    result.provider.model = env["PLUNE_MODEL"];
+  }
+  if (env["PLUNE_TIMEOUT"] !== void 0) {
+    const n = Number(env["PLUNE_TIMEOUT"]);
+    if (!isNaN(n)) result.provider.timeout = n;
+  }
+  if (env["PLUNE_MAX_RETRIES"] !== void 0) {
+    const n = Number(env["PLUNE_MAX_RETRIES"]);
+    if (!isNaN(n)) result.provider.max_retries = n;
+  }
+  return result;
+}
+var init_env_overrides = __esm({
+  "src/config/env-overrides.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/config/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  ConfigNotFoundError: () => ConfigNotFoundError,
+  ConfigValidationError: () => ConfigValidationError,
+  NonTtyError: () => NonTtyError,
+  YamlParseError: () => YamlParseError
+});
+var ConfigNotFoundError, YamlParseError, ConfigValidationError, NonTtyError;
+var init_errors = __esm({
+  "src/config/errors.ts"() {
+    "use strict";
+    init_cjs_shims();
+    ConfigNotFoundError = class extends Error {
+      code = "CFG_NOT_FOUND";
+      constructor(message) {
+        super(message);
+        this.name = "ConfigNotFoundError";
+      }
+    };
+    YamlParseError = class extends Error {
+      code = "YAML_PARSE_ERROR";
+      constructor(message) {
+        super(message);
+        this.name = "YamlParseError";
+      }
+    };
+    ConfigValidationError = class extends Error {
+      code = "CONFIG_VALIDATION_ERROR";
+      issues;
+      constructor(message, issues) {
+        super(message);
+        this.name = "ConfigValidationError";
+        this.issues = issues;
+      }
+    };
+    NonTtyError = class extends Error {
+      constructor() {
+        super("runInitWizard requires an interactive terminal (TTY)");
+        this.name = "NonTtyError";
+      }
+    };
+  }
+});
+
+// src/config/discover.ts
+function discoverConfigPath(cwd, override) {
+  if (override !== void 0) {
+    if (fs.existsSync(override)) {
+      return override;
+    }
+    throw new ConfigNotFoundError(`Config file not found: ${override}`);
+  }
+  let dir = cwd;
+  let steps = 0;
+  while (steps < MAX_STEPS) {
+    const candidate = path2.join(dir, FILENAME);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+    steps++;
+  }
+  throw new ConfigNotFoundError(
+    `No ${FILENAME} found. Run "plune init" to create one.`
+  );
+}
+var fs, path2, FILENAME, MAX_STEPS;
+var init_discover = __esm({
+  "src/config/discover.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs = __toESM(require("fs"), 1);
+    path2 = __toESM(require("path"), 1);
+    init_errors();
+    FILENAME = "plune.yaml";
+    MAX_STEPS = 50;
+  }
+});
+
+// src/config/schema.ts
+var import_zod, providerConfigSchema, modelPriceSchema, pricingSchema, datasetRowSchema, datasetRefSchema, exactMatchAssertionSchema, containsAssertionSchema, containsAnyAssertionSchema, containsAllAssertionSchema, jsonSchemaAssertionSchema, llmJudgeAssertionSchema, semanticSimilarityAssertionSchema, faithfulnessAssertionSchema, answerRelevanceAssertionSchema, contextPrecisionAssertionSchema, assertionConfigSchema, evalConfigSchema, pluneConfigSchema;
+var init_schema = __esm({
+  "src/config/schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod = require("zod");
+    providerConfigSchema = import_zod.z.object({
+      type: import_zod.z.enum(["anthropic", "openai", "openrouter"]),
+      model: import_zod.z.string().min(1),
+      temperature: import_zod.z.number().min(0).max(2).optional(),
+      max_tokens: import_zod.z.number().int().positive().optional(),
+      concurrency: import_zod.z.number().int().positive().optional(),
+      timeout: import_zod.z.number().int().positive().optional(),
+      max_retries: import_zod.z.number().int().min(0).optional()
+    });
+    modelPriceSchema = import_zod.z.object({
+      input_per_1k_usd: import_zod.z.number().nonnegative(),
+      output_per_1k_usd: import_zod.z.number().nonnegative()
+    });
+    pricingSchema = import_zod.z.record(modelPriceSchema);
+    datasetRowSchema = import_zod.z.object({
+      vars: import_zod.z.record(import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()])),
+      expected: import_zod.z.string().optional()
+    });
+    datasetRefSchema = import_zod.z.union([
+      import_zod.z.string().min(1),
+      import_zod.z.object({ examples: import_zod.z.array(datasetRowSchema).min(1) })
+    ]);
+    exactMatchAssertionSchema = import_zod.z.object({
+      type: import_zod.z.literal("exact-match"),
+      value: import_zod.z.string(),
+      trim: import_zod.z.boolean().optional(),
+      ignore_case: import_zod.z.boolean().optional()
+    });
+    containsAssertionSchema = import_zod.z.object({
+      type: import_zod.z.literal("contains"),
+      value: import_zod.z.string(),
+      ignore_case: import_zod.z.boolean().optional()
+    });
+    containsAnyAssertionSchema = import_zod.z.object({
+      type: import_zod.z.literal("contains-any"),
+      values: import_zod.z.array(import_zod.z.string()).min(1),
+      ignore_case: import_zod.z.boolean().optional()
+    });
+    containsAllAssertionSchema = import_zod.z.object({
+      type: import_zod.z.literal("contains-all"),
+      values: import_zod.z.array(import_zod.z.string()).min(1),
+      ignore_case: import_zod.z.boolean().optional()
+    });
+    jsonSchemaAssertionSchema = import_zod.z.object({
+      type: import_zod.z.literal("json-schema"),
+      schema: import_zod.z.record(import_zod.z.unknown()),
+      extract: import_zod.z.enum(["auto", "strict"]).optional()
+    });
+    llmJudgeAssertionSchema = import_zod.z.object({
+      type: import_zod.z.literal("llm-judge"),
+      criteria: import_zod.z.string().min(1),
+      provider: providerConfigSchema.partial().optional(),
+      pass_threshold: import_zod.z.number().min(0).max(1).optional()
+    });
+    semanticSimilarityAssertionSchema = import_zod.z.object({
+      type: import_zod.z.literal("semantic-similarity"),
+      reference: import_zod.z.string().min(1),
+      threshold: import_zod.z.number().min(0).max(1).optional()
+    });
+    faithfulnessAssertionSchema = import_zod.z.object({
+      type: import_zod.z.literal("faithfulness"),
+      context: import_zod.z.string().min(1),
+      threshold: import_zod.z.number().min(0).max(1).optional()
+    });
+    answerRelevanceAssertionSchema = import_zod.z.object({
+      type: import_zod.z.literal("answer-relevance"),
+      question: import_zod.z.string().min(1),
+      threshold: import_zod.z.number().min(0).max(1).optional()
+    });
+    contextPrecisionAssertionSchema = import_zod.z.object({
+      type: import_zod.z.literal("context-precision"),
+      context: import_zod.z.string().min(1),
+      question: import_zod.z.string().min(1),
+      threshold: import_zod.z.number().min(0).max(1).optional()
+    });
+    assertionConfigSchema = import_zod.z.discriminatedUnion("type", [
+      exactMatchAssertionSchema,
+      containsAssertionSchema,
+      containsAnyAssertionSchema,
+      containsAllAssertionSchema,
+      jsonSchemaAssertionSchema,
+      llmJudgeAssertionSchema,
+      semanticSimilarityAssertionSchema,
+      faithfulnessAssertionSchema,
+      answerRelevanceAssertionSchema,
+      contextPrecisionAssertionSchema
+    ]);
+    evalConfigSchema = import_zod.z.object({
+      id: import_zod.z.string().min(1).regex(/^[a-z0-9_-]+$/, "id must be lowercase slug"),
+      description: import_zod.z.string().optional(),
+      tags: import_zod.z.array(import_zod.z.string()).optional(),
+      provider: providerConfigSchema.partial().optional(),
+      prompt: import_zod.z.string().optional(),
+      prompt_file: import_zod.z.string().optional(),
+      dataset: datasetRefSchema,
+      assertions: import_zod.z.array(assertionConfigSchema)
+    }).refine(
+      (data) => !(data.prompt !== void 0 && data.prompt_file !== void 0),
+      { message: "prompt and prompt_file are mutually exclusive" }
+    );
+    pluneConfigSchema = import_zod.z.object({
+      version: import_zod.z.literal(1),
+      provider: providerConfigSchema,
+      defaults: import_zod.z.object({ assertions: import_zod.z.array(assertionConfigSchema).optional() }).optional(),
+      pricing: pricingSchema.optional(),
+      evals: import_zod.z.array(evalConfigSchema).min(1)
+    }).strict();
+  }
+});
+
+// src/config/loader.ts
+async function loadConfig(opts = {}) {
+  const { configPath, cwd = process.cwd(), env = process.env } = opts;
+  const resolvedPath = discoverConfigPath(cwd, configPath);
+  let raw;
+  try {
+    raw = await fs2.readFile(resolvedPath, "utf8");
+  } catch {
+    throw new ConfigNotFoundError(`Cannot read config file: ${resolvedPath}`);
+  }
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(raw);
+  } catch (err) {
+    throw new YamlParseError(
+      `YAML parse error in ${resolvedPath}: ${err.message}`
+    );
+  }
+  const result = pluneConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map(
+      (issue) => `${issue.path.join(".")}: ${issue.message}`
+    );
+    throw new ConfigValidationError(
+      `Config validation failed in ${resolvedPath}`,
+      issues
+    );
+  }
+  return applyEnvOverrides(result.data, env);
+}
+var fs2, import_yaml;
+var init_loader = __esm({
+  "src/config/loader.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs2 = __toESM(require("fs/promises"), 1);
+    import_yaml = require("yaml");
+    init_env_overrides();
+    init_errors();
+    init_discover();
+    init_schema();
+  }
+});
+
+// src/providers/errors.ts
+var errors_exports2 = {};
+__export(errors_exports2, {
+  AuthError: () => AuthError,
+  ProviderError: () => ProviderError,
+  classifyError: () => classifyError,
+  messageOf: () => messageOf,
+  normalizeProviderError: () => normalizeProviderError,
+  redactSecrets: () => redactSecrets
+});
+function statusOf(err) {
+  if (typeof err === "object" && err !== null && "status" in err) {
+    const s = err.status;
+    if (typeof s === "number") return s;
+  }
+  return void 0;
+}
+function codeOf(err) {
+  if (typeof err === "object" && err !== null && "code" in err) {
+    const c = err.code;
+    if (typeof c === "string") return c;
+  }
+  return void 0;
+}
+function classifyError(err) {
+  const status = statusOf(err);
+  if (status !== void 0) {
+    if (status === 401 || status === 403) return "auth";
+    if (status === 429 || status >= 500 && status <= 599) return "transient";
+    return "fatal";
+  }
+  const code = codeOf(err);
+  if (code !== void 0 && NETWORK_ERROR_CODES.has(code)) return "transient";
+  if (isTransportError(err)) return "transient";
+  return "fatal";
+}
+function isTransportError(err) {
+  if (typeof err !== "object" || err === null) return false;
+  const e = err;
+  const names = [e.name, e.constructor?.name].filter(
+    (n) => typeof n === "string"
+  );
+  return names.some(
+    (n) => /APIConnection|ConnectionError|TimeoutError|AbortError|FetchError/.test(n)
+  );
+}
+function redactSecrets(message, ...secrets) {
+  let out = message;
+  for (const secret of secrets) {
+    if (secret) out = out.split(secret).join("[REDACTED]");
+  }
+  out = out.replace(/Bearer\s+[A-Za-z0-9._-]+/g, "Bearer [REDACTED]");
+  return out;
+}
+function messageOf(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "object" && err !== null && "message" in err) {
+    return String(err.message);
+  }
+  return String(err);
+}
+function normalizeProviderError(err, secret, envVar) {
+  if (err instanceof AuthError) return err;
+  if (classifyError(err) === "auth") {
+    return new AuthError(redactSecrets(messageOf(err), secret), envVar);
+  }
+  if (err instanceof ProviderError) {
+    return new ProviderError(err.code, redactSecrets(err.message, secret));
+  }
+  return new ProviderError("PROVIDER_ERROR", redactSecrets(messageOf(err), secret));
+}
+var NETWORK_ERROR_CODES, AuthError, ProviderError;
+var init_errors2 = __esm({
+  "src/providers/errors.ts"() {
+    "use strict";
+    init_cjs_shims();
+    NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+      "ECONNRESET",
+      "ETIMEDOUT",
+      "ECONNREFUSED",
+      "EPIPE",
+      "ENOTFOUND",
+      "EAI_AGAIN"
+    ]);
+    AuthError = class extends Error {
+      code = "PROVIDER_AUTH";
+      envVar;
+      constructor(message, envVar) {
+        super(message);
+        this.name = "AuthError";
+        this.envVar = envVar;
+      }
+    };
+    ProviderError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.name = "ProviderError";
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/providers/retry.ts
+function retryAfterMs(err) {
+  if (typeof err !== "object" || err === null || !("headers" in err)) return void 0;
+  const raw = readHeader(err.headers, "retry-after");
+  if (raw === void 0) return void 0;
+  const seconds = Number(raw);
+  if (!Number.isFinite(seconds) || seconds < 0) return void 0;
+  return seconds * 1e3;
+}
+function readHeader(headers, name) {
+  if (headers === null || typeof headers !== "object" && typeof headers !== "function") {
+    return void 0;
+  }
+  const getter = headers.get;
+  if (typeof getter === "function") {
+    const v2 = getter.call(headers, name);
+    return v2 === null ? void 0 : v2;
+  }
+  const v = headers[name];
+  return typeof v === "string" || typeof v === "number" ? v : void 0;
+}
+async function withRetry(fn, options) {
+  const { base_delay_ms = 500, sleep = defaultSleep, random = Math.random } = options;
+  const maxRetries = Math.max(0, Math.floor(options.max_retries));
+  let attempt = 0;
+  for (; ; ) {
+    try {
+      return await fn();
+    } catch (err) {
+      const klass = classifyError(err);
+      if (klass === "auth") throw err;
+      if (klass === "fatal") throw new ProviderError("PROVIDER_FATAL", messageOf(err));
+      if (attempt >= maxRetries) {
+        throw new ProviderError("PROVIDER_TRANSIENT_EXHAUSTED", messageOf(err));
+      }
+      const backoff = base_delay_ms * 2 ** attempt;
+      const jitter = backoff * 0.1 * random();
+      const delay = Math.max(backoff + jitter, retryAfterMs(err) ?? 0);
+      await sleep(delay);
+      attempt += 1;
+    }
+  }
+}
+var defaultSleep;
+var init_retry = __esm({
+  "src/providers/retry.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_errors2();
+    defaultSleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+  }
+});
+
+// src/providers/prices.ts
+var PRICE_TABLE;
+var init_prices = __esm({
+  "src/providers/prices.ts"() {
+    "use strict";
+    init_cjs_shims();
+    PRICE_TABLE = {
+      // Anthropic
+      "claude-3-5-haiku-latest": { input_per_1k_usd: 8e-4, output_per_1k_usd: 4e-3 },
+      "claude-3-5-sonnet-latest": { input_per_1k_usd: 3e-3, output_per_1k_usd: 0.015 },
+      "claude-3-opus-latest": { input_per_1k_usd: 0.015, output_per_1k_usd: 0.075 },
+      // OpenAI
+      "gpt-4o": { input_per_1k_usd: 25e-4, output_per_1k_usd: 0.01 },
+      "gpt-4o-mini": { input_per_1k_usd: 15e-5, output_per_1k_usd: 6e-4 },
+      // OpenAI via OpenRouter (namespaced ids). OpenRouter passes OpenAI list price through for
+      // openai/* routes, so these mirror the direct entries. Only a few common ids are listed —
+      // OpenRouter has hundreds of models and dynamic routing, so most still need a `pricing` entry
+      // in plune.yaml (or report cost_usd=0). Verify against OpenRouter's current rates.
+      "openai/gpt-4o": { input_per_1k_usd: 25e-4, output_per_1k_usd: 0.01 },
+      "openai/gpt-4o-mini": { input_per_1k_usd: 15e-5, output_per_1k_usd: 6e-4 }
+    };
+  }
+});
+
+// src/providers/cost.ts
+function priceFrom(price, usage) {
+  return usage.input_tokens / 1e3 * price.input_per_1k_usd + usage.output_tokens / 1e3 * price.output_per_1k_usd;
+}
+function resolveCost(usage, model, reportedCostUsd, overrides, deps = {}) {
+  const table = deps.table ?? PRICE_TABLE;
+  const warn = deps.warn ?? defaultWarn;
+  const override = overrides?.[model];
+  if (override !== void 0) {
+    return priceFrom(override, usage);
+  }
+  if (reportedCostUsd !== void 0) {
+    return reportedCostUsd;
+  }
+  const tablePrice = table[model];
+  if (tablePrice !== void 0) {
+    return priceFrom(tablePrice, usage);
+  }
+  warn(
+    `plune: no price for model "${model}" \u2014 reporting cost_usd=0. Set pricing["${model}"] in plune.yaml to track its cost.`
+  );
+  return 0;
+}
+var defaultWarn;
+var init_cost = __esm({
+  "src/providers/cost.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_prices();
+    defaultWarn = (message) => {
+      process.stderr.write(message + "\n");
+    };
+  }
+});
+
+// src/providers/anthropic.ts
+function makeAnthropicProvider(config, env, pricing) {
+  const apiKey = env[ENV_VAR];
+  if (apiKey === void 0 || apiKey.trim() === "") {
+    throw new AuthError(
+      `Missing ${ENV_VAR}. Set it in your environment to use the anthropic provider.`,
+      ENV_VAR
+    );
+  }
+  const client = new import_sdk.default({
+    apiKey,
+    maxRetries: 0,
+    ...config.timeout !== void 0 ? { timeout: config.timeout } : {}
+  });
+  const maxRetries = config.max_retries ?? DEFAULT_MAX_RETRIES;
+  return {
+    async complete(req) {
+      try {
+        const res = await withRetry(
+          () => client.messages.create({
+            model: req.model,
+            max_tokens: req.max_tokens,
+            temperature: req.temperature,
+            messages: [{ role: "user", content: req.prompt_resolved }]
+          }),
+          { max_retries: maxRetries }
+        );
+        const output = res.content.map((block) => block.type === "text" ? block.text : "").join("");
+        return {
+          output,
+          usage: {
+            input_tokens: res.usage.input_tokens,
+            output_tokens: res.usage.output_tokens
+          }
+        };
+      } catch (err) {
+        throw normalizeProviderError(err, apiKey, ENV_VAR);
+      }
+    },
+    estimateCost(usage, reportedCostUsd) {
+      return { cost_usd: resolveCost(usage, config.model, reportedCostUsd, pricing) };
+    }
+  };
+}
+var import_sdk, ENV_VAR, DEFAULT_MAX_RETRIES;
+var init_anthropic = __esm({
+  "src/providers/anthropic.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+    init_retry();
+    init_cost();
+    init_errors2();
+    ENV_VAR = "ANTHROPIC_API_KEY";
+    DEFAULT_MAX_RETRIES = 2;
+  }
+});
+
+// src/providers/openai.ts
+function makeOpenAiCompatibleProvider(opts) {
+  const { config, env, pricing, apiKeyEnv, baseURL, reportsCost } = opts;
+  const apiKey = env[apiKeyEnv];
+  if (apiKey === void 0 || apiKey.trim() === "") {
+    throw new AuthError(
+      `Missing ${apiKeyEnv}. Set it in your environment to use the ${config.type} provider.`,
+      apiKeyEnv
+    );
+  }
+  const client = new import_openai.default({
+    apiKey,
+    maxRetries: 0,
+    // our own withRetry owns retry (ADR-PRV03)
+    ...baseURL !== void 0 ? { baseURL } : {},
+    ...config.timeout !== void 0 ? { timeout: config.timeout } : {}
+  });
+  const maxRetries = config.max_retries ?? DEFAULT_MAX_RETRIES2;
+  return {
+    async complete(req) {
+      try {
+        const res = await withRetry(
+          () => client.chat.completions.create({
+            model: req.model,
+            temperature: req.temperature,
+            max_tokens: req.max_tokens,
+            messages: [{ role: "user", content: req.prompt_resolved }],
+            // OpenRouter extension: ask it to include the call's actual cost in `usage` (ADR-PRC02).
+            ...reportsCost ? { usage: { include: true } } : {}
+          }),
+          { max_retries: maxRetries }
+        );
+        const reportedCost = reportsCost ? res.usage?.cost : void 0;
+        return {
+          output: res.choices[0]?.message?.content ?? "",
+          usage: {
+            input_tokens: res.usage?.prompt_tokens ?? 0,
+            output_tokens: res.usage?.completion_tokens ?? 0
+          },
+          ...typeof reportedCost === "number" ? { cost_usd: reportedCost } : {}
+        };
+      } catch (err) {
+        throw normalizeProviderError(err, apiKey, apiKeyEnv);
+      }
+    },
+    estimateCost(usage, reportedCostUsd) {
+      return { cost_usd: resolveCost(usage, config.model, reportedCostUsd, pricing) };
+    }
+  };
+}
+function makeOpenAiProvider(config, env, pricing) {
+  return makeOpenAiCompatibleProvider({ config, env, pricing, apiKeyEnv: "OPENAI_API_KEY" });
+}
+var import_openai, DEFAULT_MAX_RETRIES2;
+var init_openai = __esm({
+  "src/providers/openai.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_openai = __toESM(require("openai"), 1);
+    init_retry();
+    init_cost();
+    init_errors2();
+    DEFAULT_MAX_RETRIES2 = 2;
+  }
+});
+
+// src/providers/openrouter.ts
+function makeOpenRouterProvider(config, env, pricing) {
+  return makeOpenAiCompatibleProvider({
+    config,
+    env,
+    pricing,
+    apiKeyEnv: "OPENROUTER_API_KEY",
+    baseURL: OPENROUTER_BASE_URL,
+    reportsCost: true
+    // OpenRouter reports the call's actual cost via usage.cost (ADR-PRC02)
+  });
+}
+var OPENROUTER_BASE_URL;
+var init_openrouter = __esm({
+  "src/providers/openrouter.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_openai();
+    OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+  }
+});
+
+// src/providers/registry.ts
+function createProviderRegistry() {
+  const factories = /* @__PURE__ */ new Map();
+  return {
+    register(name, factory) {
+      if (factories.has(name)) {
+        throw new Error(`Provider "${name}" is already registered \u2014 provider names must be unique.`);
+      }
+      factories.set(name, factory);
+    },
+    resolve(name, config, env, pricing) {
+      const factory = factories.get(name);
+      if (factory === void 0) {
+        const known = [...factories.keys()].join(", ") || "(none)";
+        throw new Error(`Unknown provider type "${name}". Registered providers: ${known}.`);
+      }
+      return factory(config, env, pricing);
+    },
+    has(name) {
+      return factories.has(name);
+    }
+  };
+}
+function createDefaultRegistry() {
+  const registry = createProviderRegistry();
+  registry.register("anthropic", makeAnthropicProvider);
+  registry.register("openai", makeOpenAiProvider);
+  registry.register("openrouter", makeOpenRouterProvider);
+  return registry;
+}
+function getProvider(config, env, pricing) {
+  return createDefaultRegistry().resolve(config.type, config, env, pricing);
+}
+var init_registry = __esm({
+  "src/providers/registry.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_anthropic();
+    init_openai();
+    init_openrouter();
+  }
+});
+
+// src/providers/index.ts
+var init_providers = __esm({
+  "src/providers/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_registry();
+    init_errors2();
+    init_cost();
+    init_prices();
+  }
+});
+
+// src/providers/mock.ts
+function makeMockProvider() {
+  return {
+    complete: () => Promise.resolve({
+      output: "mock response",
+      usage: { input_tokens: 10, output_tokens: 5 }
+    }),
+    estimateCost: () => ({ cost_usd: 0 })
+  };
+}
+var init_mock = __esm({
+  "src/providers/mock.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/embeddings/cosine.ts
+function cosine(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`cosine: vector length mismatch (${a.length} vs ${b.length})`);
+  }
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    dot += x * y;
+    normA += x * x;
+    normB += y * y;
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+var init_cosine = __esm({
+  "src/embeddings/cosine.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/embeddings/embedder.ts
+function getDefaultEmbedder() {
+  return defaultEmbedder ??= new XenovaEmbedder();
+}
+var MODEL_ID, XenovaEmbedder, defaultEmbedder;
+var init_embedder = __esm({
+  "src/embeddings/embedder.ts"() {
+    "use strict";
+    init_cjs_shims();
+    MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+    XenovaEmbedder = class {
+      extractor;
+      async embed(texts) {
+        const extract = await this.load();
+        const output = await extract(texts, { pooling: "mean", normalize: true });
+        const rows = output.tolist();
+        return rows.map((row) => Float32Array.from(row));
+      }
+      load() {
+        this.extractor ??= import("@huggingface/transformers").then(
+          ({ pipeline }) => pipeline("feature-extraction", MODEL_ID)
+        );
+        return this.extractor;
+      }
+    };
+  }
+});
+
+// src/embeddings/index.ts
+var init_embeddings = __esm({
+  "src/embeddings/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_cosine();
+    init_embedder();
+  }
+});
+
+// src/cache/cache.ts
+function openCache(file, opts = {}) {
+  const now = opts.now ?? Date.now;
+  try {
+    const db = new import_better_sqlite3.default(file);
+    try {
+      ensureSchema(db);
+    } catch (err) {
+      db.close();
+      throw err;
+    }
+    return new SqliteCache(db, now);
+  } catch {
+    return new NoOpCache();
+  }
+}
+function ensureSchema(db) {
+  db.exec(META_DDL + COMPLETIONS_DDL);
+  const stored = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+  const current = String(SCHEMA_VERSION);
+  if (stored !== current) {
+    db.exec("DROP TABLE IF EXISTS completions");
+    db.exec(COMPLETIONS_DDL);
+    db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run("schema_version", current);
+  }
+}
+var import_better_sqlite3, SCHEMA_VERSION, META_DDL, COMPLETIONS_DDL, SqliteCache, NoOpCache;
+var init_cache = __esm({
+  "src/cache/cache.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+    SCHEMA_VERSION = 1;
+    META_DDL = "CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);";
+    COMPLETIONS_DDL = "CREATE TABLE IF NOT EXISTS completions (cache_key TEXT PRIMARY KEY, output TEXT NOT NULL, input_tokens INTEGER NOT NULL, output_tokens INTEGER NOT NULL, created_at INTEGER NOT NULL);";
+    SqliteCache = class {
+      constructor(db, now) {
+        this.db = db;
+        this.now = now;
+      }
+      db;
+      now;
+      get(key, opts = {}) {
+        try {
+          const row = this.db.prepare("SELECT output, input_tokens, output_tokens, created_at FROM completions WHERE cache_key = ?").get(key);
+          if (row === void 0) return void 0;
+          if (opts.maxAgeMs !== void 0 && this.now() - row.created_at > opts.maxAgeMs) {
+            return void 0;
+          }
+          return {
+            output: row.output,
+            usage: { input_tokens: row.input_tokens, output_tokens: row.output_tokens }
+          };
+        } catch {
+          return void 0;
+        }
+      }
+      set(key, value) {
+        try {
+          this.db.prepare(
+            `INSERT INTO completions (cache_key, output, input_tokens, output_tokens, created_at)
+           VALUES (?, ?, ?, ?, ?)
+           ON CONFLICT(cache_key) DO UPDATE SET
+             output = excluded.output,
+             input_tokens = excluded.input_tokens,
+             output_tokens = excluded.output_tokens,
+             created_at = excluded.created_at`
+          ).run(key, value.output, value.usage.input_tokens, value.usage.output_tokens, this.now());
+        } catch {
+        }
+      }
+      clear() {
+        try {
+          this.db.exec("DELETE FROM completions");
+        } catch {
+        }
+      }
+      close() {
+        this.db.close();
+      }
+    };
+    NoOpCache = class {
+      get() {
+        return void 0;
+      }
+      set() {
+      }
+      clear() {
+      }
+      close() {
+      }
+    };
+  }
+});
+
+// src/cache/index.ts
+var init_cache2 = __esm({
+  "src/cache/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_cache();
+  }
+});
+
+// src/util/canonical-json.ts
+function normalizeValue(value) {
+  if (value === null) return null;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!isFinite(value)) {
+      throw new Error(
+        `canonicalJson: non-finite number rejected: ${String(value)}`
+      );
+    }
+    return value === 0 ? 0 : value;
+  }
+  if (typeof value === "string") {
+    return value.normalize("NFC");
+  }
+  if (Array.isArray(value)) {
+    return value.map(normalizeValue);
+  }
+  if (typeof value === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== null && proto !== Object.prototype) {
+      const name = value.constructor?.name ?? "unknown";
+      throw new Error(
+        `canonicalJson: unsupported non-plain object (${name}) \u2014 only plain objects, arrays, and primitives are serializable`
+      );
+    }
+    const obj = value;
+    const sorted = {};
+    for (const key of Object.keys(obj).sort()) {
+      sorted[key] = normalizeValue(obj[key]);
+    }
+    return sorted;
+  }
+  throw new Error(
+    `canonicalJson: unsupported value type: ${typeof value}`
+  );
+}
+function canonicalJson(value) {
+  return JSON.stringify(normalizeValue(value));
+}
+var init_canonical_json = __esm({
+  "src/util/canonical-json.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/util/hash.ts
+function sha256(input) {
+  return (0, import_node_crypto.createHash)("sha256").update(input, "utf8").digest("hex");
+}
+function cacheKey(inputs) {
+  const { provider, model, temperature, max_tokens, prompt_resolved } = inputs;
+  return sha256(canonicalJson({ provider, model, temperature, max_tokens, prompt_resolved }));
+}
+function configHash(config) {
+  return sha256(canonicalJson(config));
+}
+var import_node_crypto;
+var init_hash = __esm({
+  "src/util/hash.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_crypto = require("crypto");
+    init_canonical_json();
+  }
+});
+
+// src/assertions/interpolate.ts
+function interpolate(template, ctx) {
+  return template.replace(PLACEHOLDER, (match, key) => {
+    if (key === "expected") {
+      return ctx.row.expected ?? "";
+    }
+    if (key.startsWith("vars.")) {
+      const name = key.slice("vars.".length);
+      const value = ctx.vars[name];
+      return value === void 0 ? match : String(value);
+    }
+    return match;
+  });
+}
+var PLACEHOLDER;
+var init_interpolate = __esm({
+  "src/assertions/interpolate.ts"() {
+    "use strict";
+    init_cjs_shims();
+    PLACEHOLDER = /\{\{\s*([\w.]+)\s*\}\}/g;
+  }
+});
+
+// src/assertions/exact-match.ts
+var exactMatch;
+var init_exact_match = __esm({
+  "src/assertions/exact-match.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_interpolate();
+    exactMatch = {
+      run(ctx) {
+        const expected = interpolate(ctx.params.value, ctx);
+        let actual = ctx.output;
+        let target = expected;
+        if (ctx.params.trim) {
+          actual = actual.trim();
+          target = target.trim();
+        }
+        if (ctx.params.ignore_case) {
+          actual = actual.toLowerCase();
+          target = target.toLowerCase();
+        }
+        const result = actual === target ? { passed: true } : { passed: false, reason: `expected exact match: "${expected}"` };
+        return Promise.resolve(result);
+      }
+    };
+  }
+});
+
+// src/assertions/contains.ts
+function norm(s, ignoreCase) {
+  return ignoreCase ? s.toLowerCase() : s;
+}
+var contains, containsAny, containsAll;
+var init_contains = __esm({
+  "src/assertions/contains.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_interpolate();
+    contains = {
+      run(ctx) {
+        const value = interpolate(ctx.params.value, ctx);
+        const found = norm(ctx.output, ctx.params.ignore_case).includes(
+          norm(value, ctx.params.ignore_case)
+        );
+        return Promise.resolve(
+          found ? { passed: true } : { passed: false, reason: `expected output to contain: "${value}"` }
+        );
+      }
+    };
+    containsAny = {
+      run(ctx) {
+        const hay = norm(ctx.output, ctx.params.ignore_case);
+        const values = ctx.params.values.map((v) => interpolate(v, ctx));
+        const found = values.some((v) => hay.includes(norm(v, ctx.params.ignore_case)));
+        return Promise.resolve(
+          found ? { passed: true } : { passed: false, reason: `expected output to contain any of: ${JSON.stringify(values)}` }
+        );
+      }
+    };
+    containsAll = {
+      run(ctx) {
+        const hay = norm(ctx.output, ctx.params.ignore_case);
+        const values = ctx.params.values.map((v) => interpolate(v, ctx));
+        const missing = values.filter((v) => !hay.includes(norm(v, ctx.params.ignore_case)));
+        return Promise.resolve(
+          missing.length === 0 ? { passed: true } : { passed: false, reason: `output is missing required substrings: ${JSON.stringify(missing)}` }
+        );
+      }
+    };
+  }
+});
+
+// src/assertions/json-extract.ts
+function extractJson(output, mode) {
+  if (mode === "strict") {
+    return tryParse(output.trim());
+  }
+  const fenced = extractFencedBlock(output);
+  if (fenced !== null) {
+    const r = tryParse(fenced);
+    if (r.ok) return r;
+  }
+  for (const run of balancedRuns(output)) {
+    const r = tryParse(run);
+    if (r.ok) return r;
+  }
+  return { ok: false };
+}
+function tryParse(s) {
+  try {
+    return { ok: true, value: JSON.parse(s) };
+  } catch {
+    return { ok: false };
+  }
+}
+function extractFencedBlock(s) {
+  const m = s.match(/```(?:json)?\s*\n?([\s\S]*?)```/i);
+  return m?.[1]?.trim() ?? null;
+}
+function* balancedRuns(s) {
+  let i = 0;
+  while (i < s.length) {
+    const rel = s.slice(i).search(/[{[]/);
+    if (rel === -1) return;
+    const start = i + rel;
+    const run = balancedFrom(s, start);
+    if (run === null) {
+      i = start + 1;
+    } else {
+      yield run;
+      i = start + run.length;
+    }
+  }
+}
+function balancedFrom(s, start) {
+  const open = s[start];
+  const close = open === "{" ? "}" : "]";
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < s.length; i++) {
+    const ch = s[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === open) {
+      depth++;
+    } else if (ch === close) {
+      depth--;
+      if (depth === 0) return s.slice(start, i + 1);
+    }
+  }
+  return null;
+}
+var init_json_extract = __esm({
+  "src/assertions/json-extract.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/assertions/json-schema.ts
+var import_ajv, jsonSchema;
+var init_json_schema = __esm({
+  "src/assertions/json-schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ajv = require("ajv");
+    init_json_extract();
+    jsonSchema = {
+      run(ctx) {
+        const mode = ctx.params.extract ?? "auto";
+        const extracted = extractJson(ctx.output, mode);
+        if (!extracted.ok) {
+          return Promise.resolve({
+            passed: false,
+            reason: `output is not valid JSON (extract mode: ${mode})`
+          });
+        }
+        const ajv = new import_ajv.Ajv({ allErrors: true });
+        let validate;
+        try {
+          validate = ajv.compile(ctx.params.schema);
+        } catch (err) {
+          return Promise.resolve({
+            passed: false,
+            reason: `invalid json-schema: ${err.message}`
+          });
+        }
+        if (validate(extracted.value)) {
+          return Promise.resolve({ passed: true });
+        }
+        return Promise.resolve({
+          passed: false,
+          reason: `json-schema validation failed: ${ajv.errorsText(validate.errors, { separator: "; " })}`
+        });
+      }
+    };
+  }
+});
+
+// src/assertions/semantic-similarity.ts
+var DEFAULT_THRESHOLD, semanticSimilarity;
+var init_semantic_similarity = __esm({
+  "src/assertions/semantic-similarity.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_interpolate();
+    init_cosine();
+    DEFAULT_THRESHOLD = 0.8;
+    semanticSimilarity = {
+      async run(ctx) {
+        if (ctx.embedder === void 0) {
+          throw new Error("semantic-similarity requires an embedder in the AssertionContext");
+        }
+        const reference = interpolate(ctx.params.reference, ctx);
+        const threshold = ctx.params.threshold ?? DEFAULT_THRESHOLD;
+        const vecs = await ctx.embedder.embed([ctx.output, reference]);
+        const [outVec, refVec] = vecs;
+        if (outVec === void 0 || refVec === void 0) {
+          throw new Error(`semantic-similarity: embedder returned ${vecs.length} vector(s), expected 2`);
+        }
+        const score = cosine(outVec, refVec);
+        return score >= threshold ? { passed: true, score } : {
+          passed: false,
+          score,
+          reason: `similarity ${score.toFixed(3)} < threshold ${threshold}`
+        };
+      }
+    };
+  }
+});
+
+// src/assertions/judge-helpers.ts
+async function askJson(judge, prompt5) {
+  const text2 = await judge.ask(prompt5);
+  const result = extractJson(text2, "auto");
+  if (!result.ok) {
+    throw new Error(`judge returned no parseable JSON (got: ${text2.slice(0, 120)})`);
+  }
+  return result.value;
+}
+function asObject(judgment) {
+  if (typeof judgment !== "object" || judgment === null) {
+    throw new Error("judge response is not a JSON object");
+  }
+  return judgment;
+}
+function parseScored(judgment) {
+  const obj = asObject(judgment);
+  const raw = obj["score"];
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    throw new Error('judge response missing a finite numeric "score"');
+  }
+  const score = Math.max(0, Math.min(1, raw));
+  const reason = obj["reason"];
+  return typeof reason === "string" ? { score, reason } : { score };
+}
+function parseStatements(judgment) {
+  const arr = asObject(judgment)["statements"];
+  if (!Array.isArray(arr)) {
+    throw new Error('judge response missing "statements" array');
+  }
+  return arr.map(
+    (s) => typeof s === "object" && s !== null && s["faithful"] === true
+  );
+}
+function parseQuestions(judgment) {
+  const arr = asObject(judgment)["questions"];
+  if (!Array.isArray(arr)) {
+    throw new Error('judge response missing "questions" array');
+  }
+  return arr.filter((q) => typeof q === "string");
+}
+var init_judge_helpers = __esm({
+  "src/assertions/judge-helpers.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_json_extract();
+  }
+});
+
+// src/assertions/llm-judge.ts
+function prompt(criteria, output) {
+  return `You are a strict evaluator. Score from 0 to 1 how well the OUTPUT meets the CRITERIA. Respond ONLY with JSON: {"score": <0..1>, "reason": "<short explanation>"}.
+
+CRITERIA: ${criteria}
+
+OUTPUT:
+${output}`;
+}
+var DEFAULT_PASS_THRESHOLD, llmJudge;
+var init_llm_judge = __esm({
+  "src/assertions/llm-judge.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_interpolate();
+    init_judge_helpers();
+    DEFAULT_PASS_THRESHOLD = 0.5;
+    llmJudge = {
+      async run(ctx) {
+        if (ctx.judge === void 0) {
+          throw new Error("llm-judge requires a judge in the AssertionContext");
+        }
+        const criteria = interpolate(ctx.params.criteria, ctx);
+        const threshold = ctx.params.pass_threshold ?? DEFAULT_PASS_THRESHOLD;
+        const { score, reason } = parseScored(await askJson(ctx.judge, prompt(criteria, ctx.output)));
+        const passed = score >= threshold;
+        return {
+          passed,
+          score,
+          reason: reason ?? `score ${score.toFixed(3)} vs threshold ${threshold}`
+        };
+      }
+    };
+  }
+});
+
+// src/assertions/faithfulness.ts
+function prompt2(context, output) {
+  return `Extract the atomic factual claims from the OUTPUT and judge whether each is supported by the CONTEXT. Respond ONLY with JSON: {"statements":[{"claim":"<text>","faithful":<true|false>}]}.
+
+CONTEXT:
+${context}
+
+OUTPUT:
+${output}`;
+}
+var DEFAULT_THRESHOLD2, faithfulness;
+var init_faithfulness = __esm({
+  "src/assertions/faithfulness.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_interpolate();
+    init_judge_helpers();
+    DEFAULT_THRESHOLD2 = 0.7;
+    faithfulness = {
+      async run(ctx) {
+        if (ctx.judge === void 0) {
+          throw new Error("faithfulness requires a judge in the AssertionContext");
+        }
+        const context = interpolate(ctx.params.context, ctx);
+        const threshold = ctx.params.threshold ?? DEFAULT_THRESHOLD2;
+        const flags = parseStatements(await askJson(ctx.judge, prompt2(context, ctx.output)));
+        const score = flags.length === 0 ? 1 : flags.filter((f) => f).length / flags.length;
+        const passed = score >= threshold;
+        return passed ? { passed: true, score } : { passed: false, score, reason: `faithfulness ${score.toFixed(3)} < threshold ${threshold}` };
+      }
+    };
+  }
+});
+
+// src/assertions/answer-relevance.ts
+function prompt3(output) {
+  return `Generate the questions that the OUTPUT directly and fully answers. Respond ONLY with JSON: {"questions": ["<question>", ...]}.
+
+OUTPUT:
+${output}`;
+}
+var DEFAULT_THRESHOLD3, answerRelevance;
+var init_answer_relevance = __esm({
+  "src/assertions/answer-relevance.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_interpolate();
+    init_judge_helpers();
+    init_cosine();
+    DEFAULT_THRESHOLD3 = 0.7;
+    answerRelevance = {
+      async run(ctx) {
+        if (ctx.judge === void 0) {
+          throw new Error("answer-relevance requires a judge in the AssertionContext");
+        }
+        if (ctx.embedder === void 0) {
+          throw new Error("answer-relevance requires an embedder in the AssertionContext");
+        }
+        const question = interpolate(ctx.params.question, ctx);
+        const threshold = ctx.params.threshold ?? DEFAULT_THRESHOLD3;
+        const questions = parseQuestions(await askJson(ctx.judge, prompt3(ctx.output)));
+        if (questions.length === 0) {
+          return { passed: false, score: 0, reason: "judge generated no questions from the output" };
+        }
+        const vecs = await ctx.embedder.embed([question, ...questions]);
+        if (vecs.length < questions.length + 1) {
+          throw new Error(
+            `answer-relevance: embedder returned ${vecs.length} vectors, expected ${questions.length + 1}`
+          );
+        }
+        let sum = 0;
+        for (let i = 0; i < questions.length; i++) {
+          sum += cosine(vecs[0], vecs[i + 1]);
+        }
+        const score = Math.max(0, sum / questions.length);
+        const passed = score >= threshold;
+        return passed ? { passed: true, score } : { passed: false, score, reason: `answer-relevance ${score.toFixed(3)} < threshold ${threshold}` };
+      }
+    };
+  }
+});
+
+// src/assertions/context-precision.ts
+function prompt4(context, question) {
+  return `Judge from 0 to 1 how well the CONTEXT provides the information needed to answer the QUESTION. Respond ONLY with JSON: {"score": <0..1>, "reason": "<short explanation>"}.
+
+QUESTION: ${question}
+
+CONTEXT:
+${context}`;
+}
+var DEFAULT_THRESHOLD4, contextPrecision;
+var init_context_precision = __esm({
+  "src/assertions/context-precision.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_interpolate();
+    init_judge_helpers();
+    DEFAULT_THRESHOLD4 = 0.7;
+    contextPrecision = {
+      async run(ctx) {
+        if (ctx.judge === void 0) {
+          throw new Error("context-precision requires a judge in the AssertionContext");
+        }
+        const context = interpolate(ctx.params.context, ctx);
+        const question = interpolate(ctx.params.question, ctx);
+        const threshold = ctx.params.threshold ?? DEFAULT_THRESHOLD4;
+        const { score, reason } = parseScored(await askJson(ctx.judge, prompt4(context, question)));
+        const passed = score >= threshold;
+        return {
+          passed,
+          score,
+          reason: reason ?? `context-precision ${score.toFixed(3)} vs threshold ${threshold}`
+        };
+      }
+    };
+  }
+});
+
+// src/assertions/registry.ts
+function createAssertionRegistry() {
+  const impls = /* @__PURE__ */ new Map();
+  return {
+    register(type, impl) {
+      if (impls.has(type)) {
+        throw new Error(`Assertion "${type}" is already registered \u2014 assertion types must be unique.`);
+      }
+      impls.set(type, impl);
+    },
+    resolve(type) {
+      const impl = impls.get(type);
+      if (impl === void 0) {
+        const known = [...impls.keys()].join(", ") || "(none)";
+        throw new Error(`Unknown assertion type "${type}". Registered: ${known}.`);
+      }
+      return impl;
+    },
+    has(type) {
+      return impls.has(type);
+    }
+  };
+}
+function createDefaultRegistry2() {
+  const registry = createAssertionRegistry();
+  registry.register("exact-match", exactMatch);
+  registry.register("contains", contains);
+  registry.register("contains-any", containsAny);
+  registry.register("contains-all", containsAll);
+  registry.register("json-schema", jsonSchema);
+  registry.register("semantic-similarity", semanticSimilarity);
+  registry.register("llm-judge", llmJudge);
+  registry.register("faithfulness", faithfulness);
+  registry.register("answer-relevance", answerRelevance);
+  registry.register("context-precision", contextPrecision);
+  return registry;
+}
+function getAssertion(type) {
+  defaultRegistry ??= createDefaultRegistry2();
+  return defaultRegistry.resolve(type);
+}
+var defaultRegistry;
+var init_registry2 = __esm({
+  "src/assertions/registry.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_exact_match();
+    init_contains();
+    init_json_schema();
+    init_semantic_similarity();
+    init_llm_judge();
+    init_faithfulness();
+    init_answer_relevance();
+    init_context_precision();
+  }
+});
+
+// src/assertions/index.ts
+var init_assertions = __esm({
+  "src/assertions/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_registry2();
+  }
+});
+
+// src/orchestrator/judge.ts
+function buildJudge(provider, cfg, onUsage) {
+  return {
+    async ask(prompt5) {
+      const res = await provider.complete({
+        provider: cfg.type,
+        model: cfg.model,
+        temperature: 0,
+        max_tokens: cfg.max_tokens ?? DEFAULT_MAX_TOKENS,
+        prompt_resolved: prompt5
+      });
+      onUsage(res.usage);
+      return res.output;
+    }
+  };
+}
+var DEFAULT_MAX_TOKENS;
+var init_judge = __esm({
+  "src/orchestrator/judge.ts"() {
+    "use strict";
+    init_cjs_shims();
+    DEFAULT_MAX_TOKENS = 1024;
+  }
+});
+
+// src/orchestrator/concurrency.ts
+async function mapLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next;
+      next += 1;
+      results[i] = await fn(items[i], i);
+    }
+  };
+  const safeLimit = Number.isFinite(limit) && limit >= 1 ? Math.floor(limit) : 1;
+  const workerCount = Math.min(safeLimit, items.length);
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results;
+}
+var init_concurrency = __esm({
+  "src/orchestrator/concurrency.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/orchestrator/run.ts
+function resolvePrompt(template, vars) {
+  return template.replace(/\{\{\s*(\w+)\s*\}\}/g, (_match, key) => {
+    if (!(key in vars)) {
+      throw new RunConfigError(`Unknown variable "${key}" referenced in prompt`);
+    }
+    return String(vars[key]);
+  });
+}
+function toRunError(err) {
+  if (err instanceof ProviderError || err instanceof AuthError) {
+    return { code: err.code, message: err.message };
+  }
+  return { code: "ERROR", message: err instanceof Error ? err.message : String(err) };
+}
+function estimateUsage(prompt5, maxTokens) {
+  return { input_tokens: Math.ceil(prompt5.length / 4), output_tokens: maxTokens };
+}
+async function runRow(p) {
+  const t0 = p.now();
+  const prompt5 = resolvePrompt(p.template, p.row.vars);
+  const temperature = p.providerConfig.temperature ?? 0;
+  const maxTokens = p.providerConfig.max_tokens ?? DEFAULT_MAX_TOKENS2;
+  if (p.dryRun) {
+    const est = estimateUsage(prompt5, maxTokens);
+    const usage2 = { ...est, cost_usd: p.provider.estimateCost(est).cost_usd };
+    return { vars: p.row.vars, output: null, cached: false, usage: usage2, assertions: [] };
+  }
+  const key = cacheKey({
+    provider: p.providerConfig.type,
+    model: p.providerConfig.model,
+    temperature,
+    max_tokens: maxTokens,
+    prompt_resolved: prompt5
+  });
+  let output;
+  let usage;
+  let cached = false;
+  const hit = p.noCache ? void 0 : p.cache.get(key);
+  if (hit !== void 0) {
+    output = hit.output;
+    cached = true;
+    usage = {
+      input_tokens: hit.usage.input_tokens,
+      output_tokens: hit.usage.output_tokens,
+      cost_usd: 0
+    };
+  } else {
+    try {
+      const res = await p.provider.complete({
+        provider: p.providerConfig.type,
+        model: p.providerConfig.model,
+        temperature,
+        max_tokens: maxTokens,
+        prompt_resolved: prompt5
+      });
+      output = res.output;
+      usage = {
+        input_tokens: res.usage.input_tokens,
+        output_tokens: res.usage.output_tokens,
+        // Prefer the provider-reported actual cost (res.cost_usd) when present; resolveCost still
+        // lets a config pricing override win, else falls back to the table estimate (ADR-PRC01).
+        cost_usd: p.provider.estimateCost(res.usage, res.cost_usd).cost_usd
+      };
+      if (!p.noCache) p.cache.set(key, res);
+    } catch (err) {
+      return {
+        vars: p.row.vars,
+        output: null,
+        cached: false,
+        latency_ms: p.now() - t0,
+        error: toRunError(err),
+        assertions: []
+      };
+    }
+  }
+  let judgeCost = 0;
+  const judge = buildJudge(p.provider, p.providerConfig, (u) => {
+    judgeCost += p.provider.estimateCost(u).cost_usd;
+  });
+  const records = [];
+  let assertionError;
+  for (const assertion of p.assertions) {
+    try {
+      const result = await getAssertion(assertion.type).run({
+        output,
+        vars: p.row.vars,
+        row: p.row,
+        params: assertion,
+        embedder: p.embedder,
+        judge
+      });
+      records.push({
+        type: assertion.type,
+        passed: result.passed,
+        ...result.score !== void 0 ? { score: result.score } : {},
+        ...result.reason !== void 0 ? { reason: result.reason } : {}
+      });
+    } catch (err) {
+      assertionError = toRunError(err);
+      break;
+    }
+  }
+  const finalUsage = { ...usage, cost_usd: usage.cost_usd + judgeCost };
+  return {
+    vars: p.row.vars,
+    output,
+    cached,
+    usage: finalUsage,
+    latency_ms: p.now() - t0,
+    ...assertionError !== void 0 ? { error: assertionError } : {},
+    assertions: records
+  };
+}
+function selectEvals(evals, only) {
+  if (only === void 0 || only.length === 0) return evals;
+  return evals.filter(
+    (ev) => only.some(
+      (sel) => sel.startsWith("tag:") ? (ev.tags ?? []).includes(sel.slice(4)) : ev.id === sel
+    )
+  );
+}
+function resolveTemplate(ev, baseDir) {
+  if (ev.prompt !== void 0) return ev.prompt;
+  if (ev.prompt_file !== void 0) {
+    try {
+      return fs3.readFileSync(path3.resolve(baseDir, ev.prompt_file), "utf8");
+    } catch {
+      throw new RunConfigError(`Eval "${ev.id}": prompt_file not found: ${ev.prompt_file}`);
+    }
+  }
+  throw new RunConfigError(`Eval "${ev.id}" has neither prompt nor prompt_file`);
+}
+function classify(row) {
+  if (row.error !== void 0) return "errored";
+  if (row.assertions.some((a) => !a.passed)) return "failed";
+  return "passed";
+}
+async function runOrchestration(config, options, deps) {
+  const started = deps.now();
+  const dryRun = options.dryRun ?? false;
+  const noCache = options.noCache ?? false;
+  const evalResults = [];
+  const prepared = selectEvals(config.evals, options.only).map((ev) => {
+    const template = resolveTemplate(ev, deps.baseDir);
+    const rows = deps.loadDataset(ev.dataset, deps.baseDir);
+    for (const row of rows) {
+      resolvePrompt(template, row.vars);
+    }
+    return { ev, template, rows };
+  });
+  for (const { ev, template, rows } of prepared) {
+    const providerConfig = { ...config.provider, ...ev.provider };
+    const provider = deps.resolveProvider(providerConfig);
+    const limit = options.concurrency ?? providerConfig.concurrency ?? 4;
+    const rowResults = await mapLimit(
+      rows,
+      limit,
+      (row) => runRow({
+        template,
+        assertions: ev.assertions,
+        row,
+        providerConfig,
+        provider,
+        embedder: deps.embedder,
+        cache: deps.cache,
+        now: deps.now,
+        dryRun,
+        noCache
+      })
+    );
+    const passed = rowResults.every((r) => classify(r) === "passed");
+    evalResults.push({ id: ev.id, tags: ev.tags ?? [], rows: rowResults, passed });
+    if (options.bail === true && !passed) break;
+  }
+  const finished = deps.now();
+  const summary = {
+    total: 0,
+    passed: 0,
+    failed: 0,
+    errored: 0,
+    cost_usd: 0,
+    duration_ms: finished - started
+  };
+  for (const ev of evalResults) {
+    for (const row of ev.rows) {
+      summary.total += 1;
+      summary[classify(row)] += 1;
+      summary.cost_usd += row.usage?.cost_usd ?? 0;
+    }
+  }
+  return {
+    schema: 1,
+    plune_version: PLUNE_VERSION,
+    started_at: new Date(started).toISOString(),
+    finished_at: new Date(finished).toISOString(),
+    config_hash: configHash(config),
+    summary,
+    evals: evalResults
+  };
+}
+var fs3, path3, DEFAULT_MAX_TOKENS2, PLUNE_VERSION, RunConfigError;
+var init_run = __esm({
+  "src/orchestrator/run.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs3 = __toESM(require("fs"), 1);
+    path3 = __toESM(require("path"), 1);
+    init_hash();
+    init_assertions();
+    init_judge();
+    init_concurrency();
+    init_errors2();
+    DEFAULT_MAX_TOKENS2 = 1024;
+    PLUNE_VERSION = "0.1.0";
+    RunConfigError = class extends Error {
+      code = "CONFIG_ERROR";
+      constructor(message) {
+        super(message);
+        this.name = "RunConfigError";
+      }
+    };
+  }
+});
+
+// src/orchestrator/exit-code.ts
+function exitCodeFor(result) {
+  const { failed, errored } = result.summary;
+  if (failed > 0) return 1;
+  if (errored > 0) return 2;
+  return 0;
+}
+var init_exit_code = __esm({
+  "src/orchestrator/exit-code.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/orchestrator/dataset.ts
+function loadDataset(ref, baseDir) {
+  if (typeof ref !== "string") {
+    return ref.examples;
+  }
+  const content = fs4.readFileSync(path4.resolve(baseDir, ref), "utf8");
+  return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => JSON.parse(line));
+}
+var fs4, path4;
+var init_dataset = __esm({
+  "src/orchestrator/dataset.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs4 = __toESM(require("fs"), 1);
+    path4 = __toESM(require("path"), 1);
+  }
+});
+
+// src/orchestrator/index.ts
+var orchestrator_exports = {};
+__export(orchestrator_exports, {
+  RunConfigError: () => RunConfigError,
+  buildJudge: () => buildJudge,
+  exitCodeFor: () => exitCodeFor,
+  loadDataset: () => loadDataset,
+  mapLimit: () => mapLimit,
+  resolvePrompt: () => resolvePrompt,
+  runOrchestration: () => runOrchestration,
+  runRow: () => runRow
+});
+var init_orchestrator = __esm({
+  "src/orchestrator/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_run();
+    init_exit_code();
+    init_dataset();
+    init_concurrency();
+    init_judge();
+  }
+});
+
+// src/cli/commands/run.ts
+var run_exports = {};
+__export(run_exports, {
+  handleRun: () => handleRun,
+  isMockMode: () => isMockMode
+});
+function isMockMode(env) {
+  return env["PLUNE_MOCK_PROVIDER"] === "1";
+}
+function buildRealDeps(config, baseDir, dryRun) {
+  const dir = path5.join(baseDir, ".plune");
+  fs5.mkdirSync(dir, { recursive: true });
+  return {
+    resolveProvider: isMockMode(process.env) ? () => makeMockProvider() : (cfg) => getProvider(cfg, process.env, config.pricing),
+    embedder: getDefaultEmbedder(),
+    cache: dryRun ? NOOP_CACHE : openCache(path5.join(dir, "cache.db")),
+    now: Date.now,
+    loadDataset,
+    baseDir
+  };
+}
+function persist(result, baseDir) {
+  const dir = path5.join(baseDir, ".plune");
+  fs5.mkdirSync(dir, { recursive: true });
+  fs5.writeFileSync(path5.join(dir, "last-run.json"), JSON.stringify(result, null, 2));
+}
+async function handleRun(options, depsFactory) {
+  const config = await loadConfig(
+    options.configPath !== void 0 ? { configPath: options.configPath } : {}
+  );
+  const baseDir = options.configPath !== void 0 ? path5.dirname(path5.resolve(options.configPath)) : process.cwd();
+  const factory = depsFactory ?? ((c, d) => buildRealDeps(c, d, options.dryRun));
+  const deps = factory(config, baseDir);
+  try {
+    const result = await runOrchestration(
+      config,
+      {
+        dryRun: options.dryRun,
+        ...options.only !== void 0 ? { only: options.only } : {},
+        ...options.concurrency !== void 0 ? { concurrency: options.concurrency } : {},
+        ...options.noCache !== void 0 ? { noCache: options.noCache } : {},
+        ...options.bail !== void 0 ? { bail: options.bail } : {}
+      },
+      deps
+    );
+    persist(result, baseDir);
+    return result;
+  } finally {
+    deps.cache.close();
+  }
+}
+var fs5, path5, NOOP_CACHE;
+var init_run2 = __esm({
+  "src/cli/commands/run.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs5 = __toESM(require("fs"), 1);
+    path5 = __toESM(require("path"), 1);
+    init_loader();
+    init_providers();
+    init_mock();
+    init_embeddings();
+    init_cache2();
+    init_orchestrator();
+    NOOP_CACHE = { get: () => void 0, set: () => {
+    }, clear: () => {
+    }, close: () => {
+    } };
+  }
+});
+
+// src/reporters/style.ts
+function wrap(code, s) {
+  return `\x1B[${code}m${s}\x1B[0m`;
+}
+function createStyler(color) {
+  if (!color) {
+    const id = (s) => s;
+    return { green: id, red: id, yellow: id, dim: id, bold: id };
+  }
+  return {
+    green: (s) => wrap(CODE.green, s),
+    red: (s) => wrap(CODE.red, s),
+    yellow: (s) => wrap(CODE.yellow, s),
+    dim: (s) => wrap(CODE.dim, s),
+    bold: (s) => wrap(CODE.bold, s)
+  };
+}
+var CODE;
+var init_style = __esm({
+  "src/reporters/style.ts"() {
+    "use strict";
+    init_cjs_shims();
+    CODE = { green: 32, red: 31, yellow: 33, dim: 2, bold: 1 };
+  }
+});
+
+// src/reporters/helpers.ts
+function truncate(s, maxChars) {
+  if (s.length <= maxChars) return s;
+  return s.slice(0, maxChars) + "\u2026 (truncated)";
+}
+var init_helpers = __esm({
+  "src/reporters/helpers.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/reporters/console.ts
+function renderConsole(result, opts = {}) {
+  const s = createStyler(opts.color ?? false);
+  const maxOut = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT;
+  const { summary } = result;
+  const lines = [];
+  lines.push(s.bold("Plune run"));
+  const passedTxt = s.green(`${summary.passed} passed`);
+  const failedTxt = summary.failed > 0 ? s.red(`${summary.failed} failed`) : `${summary.failed} failed`;
+  const erroredTxt = summary.errored > 0 ? s.yellow(`${summary.errored} errored`) : `${summary.errored} errored`;
+  lines.push(
+    `${passedTxt} \xB7 ${failedTxt} \xB7 ${erroredTxt} \xB7 ${summary.total} total \xB7 $${summary.cost_usd.toFixed(4)} \xB7 ${summary.duration_ms}ms`
+  );
+  lines.push("");
+  for (const ev of result.evals) {
+    const mark = ev.passed ? s.green("PASS") : s.red("FAIL");
+    const tags = ev.tags.length > 0 ? s.dim(` (${ev.tags.join(", ")})`) : "";
+    lines.push(`${mark} ${s.bold(ev.id)}${tags}`);
+    let passedCount = 0;
+    for (const row of ev.rows) {
+      if (row.error !== void 0) {
+        lines.push(`  ${s.dim("vars:")} ${JSON.stringify(row.vars)}`);
+        lines.push(`  ${s.red("error:")} ${row.error.message}`);
+        continue;
+      }
+      const failed = row.assertions.filter((a) => !a.passed);
+      if (failed.length === 0) {
+        passedCount += 1;
+        continue;
+      }
+      lines.push(`  ${s.dim("vars:")} ${JSON.stringify(row.vars)}`);
+      if (row.output !== null) {
+        lines.push(`  ${s.dim("output:")} ${truncate(row.output, maxOut)}`);
+      }
+      for (const a of failed) {
+        const scoreTxt = a.score !== void 0 ? s.dim(` (score ${a.score})`) : "";
+        const reasonTxt = a.reason !== void 0 ? `: ${a.reason}` : "";
+        lines.push(`  ${s.red("x")} ${a.type}${reasonTxt}${scoreTxt}`);
+      }
+    }
+    if (passedCount > 0) {
+      lines.push(s.dim(`  ${passedCount} row(s) passed`));
+    }
+  }
+  return lines.join("\n");
+}
+var DEFAULT_MAX_OUTPUT;
+var init_console = __esm({
+  "src/reporters/console.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_style();
+    init_helpers();
+    DEFAULT_MAX_OUTPUT = 500;
+  }
+});
+
+// src/reporters/json.ts
+function renderJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+var init_json = __esm({
+  "src/reporters/json.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/reporters/markdown.ts
+function classify2(row) {
+  if (row.error !== void 0) return "errored";
+  if (row.assertions.some((a) => !a.passed)) return "failed";
+  return "passed";
+}
+function fence(content) {
+  const runs = content.match(new RegExp(TICK + "+", "g"));
+  const longest = runs ? runs.reduce((m, r) => Math.max(m, r.length), 0) : 0;
+  const bar = TICK.repeat(Math.max(3, longest + 1));
+  return `${bar}
+${content}
+${bar}`;
+}
+function renderMarkdown(result, opts = {}) {
+  const maxOut = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT2;
+  const { summary } = result;
+  const out = [];
+  out.push("# Plune run");
+  out.push("");
+  out.push("| Metric | Value |");
+  out.push("| --- | --- |");
+  out.push(`| Total | ${summary.total} |`);
+  out.push(`| Passed | ${summary.passed} |`);
+  out.push(`| Failed | ${summary.failed} |`);
+  out.push(`| Errored | ${summary.errored} |`);
+  out.push(`| Cost (USD) | ${summary.cost_usd.toFixed(4)} |`);
+  out.push(`| Duration (ms) | ${summary.duration_ms} |`);
+  out.push("");
+  const failures = [];
+  for (const ev of result.evals) {
+    for (const row of ev.rows) {
+      const state = classify2(row);
+      if (state !== "passed") failures.push({ id: ev.id, row, state });
+    }
+  }
+  if (failures.length === 0) {
+    out.push("All evals passed.");
+    return out.join("\n");
+  }
+  out.push("## Failures");
+  out.push("");
+  for (const f of failures) {
+    out.push(`### ${f.id} \u2014 ${f.state}`);
+    out.push(`- vars: ${JSON.stringify(f.row.vars)}`);
+    if (f.row.error !== void 0) {
+      out.push(`- error: ${f.row.error.message}`);
+    } else {
+      for (const a of f.row.assertions) {
+        if (a.passed) continue;
+        const reasonTxt = a.reason !== void 0 ? ` \u2014 ${a.reason}` : "";
+        const scoreTxt = a.score !== void 0 ? ` (score ${a.score})` : "";
+        out.push(`- ${a.type}${reasonTxt}${scoreTxt}`);
+      }
+      if (f.row.output !== null) {
+        out.push("");
+        out.push(fence(truncate(f.row.output, maxOut)));
+      }
+    }
+    out.push("");
+  }
+  return out.join("\n");
+}
+var DEFAULT_MAX_OUTPUT2, TICK;
+var init_markdown = __esm({
+  "src/reporters/markdown.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_helpers();
+    DEFAULT_MAX_OUTPUT2 = 500;
+    TICK = String.fromCharCode(96);
+  }
+});
+
+// src/reporters/index.ts
+var reporters_exports = {};
+__export(reporters_exports, {
+  renderConsole: () => renderConsole,
+  renderJson: () => renderJson,
+  renderMarkdown: () => renderMarkdown,
+  renderReport: () => renderReport
+});
+function renderReport(result, format, opts = {}) {
+  if (format === "json") return renderJson(result);
+  if (format === "markdown") return renderMarkdown(result, opts);
+  return renderConsole(result, opts);
+}
+var init_reporters = __esm({
+  "src/reporters/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_console();
+    init_json();
+    init_markdown();
+    init_console();
+    init_json();
+    init_markdown();
+  }
+});
+
+// src/cli/commands/report.ts
+var report_exports = {};
+__export(report_exports, {
+  ReportNotFoundError: () => ReportNotFoundError,
+  handleReport: () => handleReport
+});
+function isRunResult(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  return typeof o["summary"] === "object" && o["summary"] !== null && Array.isArray(o["evals"]);
+}
+function handleReport(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const file = path6.join(cwd, ".plune", "last-run.json");
+  let raw;
+  try {
+    raw = fs6.readFileSync(file, "utf8");
+  } catch {
+    throw new ReportNotFoundError('No saved run found. Run "plune run" first.');
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new ReportNotFoundError('Saved run is unreadable. Run "plune run" again.');
+  }
+  if (!isRunResult(parsed)) {
+    throw new ReportNotFoundError('Saved run is malformed. Run "plune run" again.');
+  }
+  return parsed;
+}
+var fs6, path6, ReportNotFoundError;
+var init_report = __esm({
+  "src/cli/commands/report.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs6 = __toESM(require("fs"), 1);
+    path6 = __toESM(require("path"), 1);
+    ReportNotFoundError = class extends Error {
+      code = "NO_SAVED_RUN";
+      constructor(message) {
+        super(message);
+        this.name = "ReportNotFoundError";
+      }
+    };
+  }
+});
+
+// src/diff/diff.ts
+function rowStatus(r) {
+  if (r.error !== void 0) return "errored";
+  if (r.assertions.some((a) => !a.passed)) return "failed";
+  return "passed";
+}
+function evalStatus(e) {
+  const statuses = e.rows.map(rowStatus);
+  if (statuses.includes("failed")) return "failed";
+  if (statuses.includes("errored")) return "errored";
+  return "passed";
+}
+function classify3(baseline, current) {
+  if (current === "errored") return "errored";
+  if (baseline === "absent") return current === "passed" ? "new-pass" : "new-fail";
+  if (current === "absent") return "removed";
+  if (baseline === "passed") return current === "passed" ? "stable-pass" : "regression";
+  return current === "passed" ? "improvement" : "pre-existing-fail";
+}
+function diffRuns(baseline, current) {
+  const baseMap = new Map(baseline.evals.map((e) => [e.id, evalStatus(e)]));
+  const curMap = new Map(current.evals.map((e) => [e.id, evalStatus(e)]));
+  const ids = [.../* @__PURE__ */ new Set([...baseMap.keys(), ...curMap.keys()])];
+  const evals = ids.map((id) => {
+    const baselineP = baseMap.get(id) ?? "absent";
+    const currentP = curMap.get(id) ?? "absent";
+    return { id, status: classify3(baselineP, currentP), baseline: baselineP, current: currentP };
+  });
+  const count = (s) => evals.filter((e) => e.status === s).length;
+  const summary = {
+    regressions: count("regression"),
+    improvements: count("improvement"),
+    preExistingFails: count("pre-existing-fail"),
+    newFails: count("new-fail"),
+    newPasses: count("new-pass"),
+    stablePasses: count("stable-pass"),
+    errored: count("errored"),
+    removed: count("removed"),
+    hasRegression: count("regression") > 0
+  };
+  return { evals, summary };
+}
+var init_diff = __esm({
+  "src/diff/diff.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// src/cli/commands/diff.ts
+var diff_exports = {};
+__export(diff_exports, {
+  DiffInputError: () => DiffInputError,
+  handleDiff: () => handleDiff
+});
+function isRunResult2(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  return Array.isArray(o["evals"]) && typeof o["summary"] === "object" && o["summary"] !== null;
+}
+function loadRunResult(file, label) {
+  let raw;
+  try {
+    raw = fs7.readFileSync(file, "utf8");
+  } catch {
+    throw new DiffInputError(`Cannot read ${label} run file: ${file}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new DiffInputError(`${label} run file is not valid JSON: ${file}`);
+  }
+  if (!isRunResult2(parsed)) {
+    throw new DiffInputError(`${label} run file is not a Plune RunResult: ${file}`);
+  }
+  return parsed;
+}
+function handleDiff(opts) {
+  const baseline = loadRunResult(opts.baselinePath, "baseline");
+  const current = loadRunResult(opts.currentPath, "current");
+  return diffRuns(baseline, current);
+}
+var fs7, DiffInputError;
+var init_diff2 = __esm({
+  "src/cli/commands/diff.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs7 = __toESM(require("fs"), 1);
+    init_diff();
+    DiffInputError = class extends Error {
+      code = "DIFF_INPUT";
+      constructor(message) {
+        super(message);
+        this.name = "DiffInputError";
+      }
+    };
+  }
+});
+
+// src/reporters/diff.ts
+var diff_exports2 = {};
+__export(diff_exports2, {
+  STICKY_MARKER: () => STICKY_MARKER,
+  renderDiff: () => renderDiff,
+  renderDiffMarkdown: () => renderDiffMarkdown
+});
+function summaryLine(d) {
+  const s = d.summary;
+  return [
+    `${s.regressions} regression(s)`,
+    `${s.improvements} improvement(s)`,
+    `${s.newFails} new-fail`,
+    `${s.preExistingFails} pre-existing-fail`,
+    `${s.errored} errored`,
+    `${s.removed} removed`,
+    `${s.stablePasses} stable`
+  ].join(" \xB7 ");
+}
+function renderDiffMarkdown(d) {
+  const out = [STICKY_MARKER, "## Plune eval diff", ""];
+  out.push(
+    d.summary.hasRegression ? `### \u274C ${d.summary.regressions} regression(s)` : "### \u2705 No regressions"
+  );
+  out.push("");
+  const notable = d.evals.filter((e) => e.status !== "stable-pass");
+  if (notable.length > 0) {
+    out.push("| Eval | Baseline \u2192 Current | Change |");
+    out.push("| --- | --- | --- |");
+    for (const e of notable) {
+      out.push(`| ${e.id} | ${e.baseline} \u2192 ${e.current} | ${BADGE[e.status]} |`);
+    }
+    out.push("");
+  }
+  out.push(`_${summaryLine(d)}_`);
+  return out.join("\n");
+}
+function renderDiffConsole(d) {
+  const out = [
+    d.summary.hasRegression ? `Plune eval diff: ${d.summary.regressions} regression(s)` : "Plune eval diff: no regressions"
+  ];
+  for (const e of d.evals) {
+    if (e.status === "stable-pass") continue;
+    out.push(`  ${e.id}: ${e.baseline} -> ${e.current} [${e.status}]`);
+  }
+  out.push(summaryLine(d));
+  return out.join("\n");
+}
+function renderDiffJson(d) {
+  return JSON.stringify(d, null, 2);
+}
+function renderDiff(d, format = "console") {
+  if (format === "json") return renderDiffJson(d);
+  if (format === "markdown") return renderDiffMarkdown(d);
+  return renderDiffConsole(d);
+}
+var STICKY_MARKER, BADGE;
+var init_diff3 = __esm({
+  "src/reporters/diff.ts"() {
+    "use strict";
+    init_cjs_shims();
+    STICKY_MARKER = "<!-- plune-eval-diff -->";
+    BADGE = {
+      regression: "\u{1F534} regression",
+      improvement: "\u{1F7E2} improvement",
+      "pre-existing-fail": "\u26AA pre-existing fail",
+      "new-fail": "\u{1F195} new fail",
+      "new-pass": "\u{1F7E2} new pass",
+      "stable-pass": "\u2705 stable",
+      errored: "\u26A0\uFE0F errored",
+      removed: "\u2796 removed"
+    };
+  }
+});
+
+// src/config/init/wizard.ts
+async function runInitWizard(cwd) {
+  if (!process.stdin.isTTY) {
+    throw new NonTtyError();
+  }
+  clack.intro("Plune \u2014 init");
+  const provider = await clack.select({
+    message: "Choose your provider:",
+    options: [
+      { value: "anthropic", label: "Anthropic (Claude)" },
+      { value: "openai", label: "OpenAI (GPT)" }
+    ]
+  });
+  if (clack.isCancel(provider)) {
+    clack.cancel("Operation cancelled.");
+    process.exit(1);
+    return;
+  }
+  const defaultModel = provider === "anthropic" ? "claude-3-opus" : "gpt-4o";
+  const model = await clack.text({
+    message: "Model name:",
+    defaultValue: defaultModel,
+    placeholder: defaultModel
+  });
+  if (clack.isCancel(model)) {
+    clack.cancel("Operation cancelled.");
+    process.exit(1);
+    return;
+  }
+  const dataset = await clack.text({
+    message: "Dataset path (JSONL):",
+    placeholder: "data/evals.jsonl"
+  });
+  if (clack.isCancel(dataset)) {
+    clack.cancel("Operation cancelled.");
+    process.exit(1);
+    return;
+  }
+  const outputPath = path7.join(cwd, "plune.yaml");
+  if (fs8.existsSync(outputPath)) {
+    const overwrite = await clack.confirm({
+      message: "plune.yaml already exists. Overwrite?"
+    });
+    if (clack.isCancel(overwrite)) {
+      clack.cancel("Operation cancelled.");
+      process.exit(1);
+      return;
+    }
+    if (!overwrite) {
+      clack.outro("No changes made.");
+      return;
+    }
+  }
+  const config = {
+    version: 1,
+    provider: {
+      type: provider,
+      model
+    },
+    evals: [
+      {
+        id: "example-eval",
+        prompt: "Replace this with your actual prompt",
+        dataset,
+        assertions: [{ type: "contains", value: "expected output" }]
+      }
+    ]
+  };
+  const header = `# Plune configuration \u2014 generated by \`plune init\`.
+#
+# version  \u2014 config schema version (always 1 in v0.1).
+# provider \u2014 which LLM backend to call: 'type' + 'model'. The API key is read from .env
+#            (see .env.example), never stored here.
+# evals    \u2014 your test cases. Each has a prompt, a dataset of variables, and assertions
+#            that must hold for the model's output.
+`;
+  const spin = clack.spinner();
+  spin.start("Writing plune.yaml\u2026");
+  fs8.writeFileSync(outputPath, header + "\n" + (0, import_yaml2.stringify)(config), "utf8");
+  spin.stop("plune.yaml created!");
+  clack.outro("Done! Run `plune run` to execute your evaluations.");
+}
+var clack, fs8, path7, import_yaml2;
+var init_wizard = __esm({
+  "src/config/init/wizard.ts"() {
+    "use strict";
+    init_cjs_shims();
+    clack = __toESM(require("@clack/prompts"), 1);
+    fs8 = __toESM(require("fs"), 1);
+    path7 = __toESM(require("path"), 1);
+    import_yaml2 = require("yaml");
+    init_errors();
+  }
+});
+
+// src/cli/templates/index.ts
+function writeTemplateFile(cwd, rel, content, force) {
+  const target = path8.join(cwd, rel);
+  if (!force && fs9.existsSync(target)) {
+    return "skipped";
+  }
+  fs9.mkdirSync(path8.dirname(target), { recursive: true });
+  fs9.writeFileSync(target, content, "utf8");
+  return "written";
+}
+var fs9, path8, ENV_EXAMPLE_TPL, EXAMPLE_JSONL_TPL, PLUNE_YAML_TPL;
+var init_templates = __esm({
+  "src/cli/templates/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs9 = __toESM(require("fs"), 1);
+    path8 = __toESM(require("path"), 1);
+    ENV_EXAMPLE_TPL = `# Copy this file to .env and replace the placeholders with your real keys.
+# .env is gitignored; .env.example is safe to commit.
+# Plune reads whichever key matches your configured provider.
+ANTHROPIC_API_KEY=YOUR_ANTHROPIC_API_KEY_HERE
+OPENAI_API_KEY=YOUR_OPENAI_API_KEY_HERE
+OPENROUTER_API_KEY=YOUR_OPENROUTER_API_KEY_HERE
+`;
+    EXAMPLE_JSONL_TPL = `{"vars":{"question":"What is 2 + 2?"},"expected":"4"}
+{"vars":{"question":"What is the capital of France?"},"expected":"Paris"}
+{"vars":{"question":"Reply with the single word: hello"},"expected":"hello"}
+`;
+    PLUNE_YAML_TPL = `# Plune configuration \u2014 generated by \`plune init --yes\`.
+#
+# version  \u2014 config schema version (always 1 in v0.1).
+# provider \u2014 which LLM backend to call: 'type' (anthropic | openai | openrouter) + 'model'.
+#            The API key is read from .env (see .env.example), never stored here.
+# evals    \u2014 your test cases: a prompt (with {{vars}}), a dataset, and assertions to check.
+version: 1
+provider:
+  type: anthropic
+  model: claude-3-5-sonnet-latest
+evals:
+  - id: example
+    prompt: "Answer concisely. {{question}}"
+    dataset: datasets/example.jsonl
+    assertions:
+      - type: contains
+        value: "the"
+`;
+  }
+});
+
+// src/cli/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initCommand: () => initCommand
+});
+function reportWrite(cwd, rel, content, force) {
+  const status = writeTemplateFile(cwd, rel, content, force);
+  process.stdout.write(
+    status === "skipped" ? `Skipped existing ${rel} (use --force to overwrite).
+` : `Created ${rel}.
+`
+  );
+}
+async function initCommand({ cwd, force, yes = false }) {
+  if (yes) {
+    reportWrite(cwd, "plune.yaml", PLUNE_YAML_TPL, force);
+  } else {
+    await runInitWizard(cwd);
+  }
+  for (const [rel, content] of TEMPLATES) {
+    reportWrite(cwd, rel, content, force);
+  }
+}
+var TEMPLATES;
+var init_init = __esm({
+  "src/cli/commands/init.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_wizard();
+    init_templates();
+    TEMPLATES = [
+      ["datasets/example.jsonl", EXAMPLE_JSONL_TPL],
+      [".env.example", ENV_EXAMPLE_TPL]
+    ];
+  }
+});
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  createProgram: () => createProgram
+});
+module.exports = __toCommonJS(cli_exports);
+init_cjs_shims();
+var import_commander = require("commander");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
+var __dirname = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+var pkg = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(__dirname, "..", "package.json"), "utf-8"));
+function toFormat(s) {
+  return s === "json" || s === "markdown" ? s : "console";
+}
+function shouldColor(outputPath) {
+  return outputPath === void 0 && process.stdout.isTTY === true && process.env.NO_COLOR === void 0;
+}
+function writeReport(text2, outputPath) {
+  if (outputPath !== void 0) {
+    (0, import_node_fs.writeFileSync)(outputPath, text2);
+  } else {
+    process.stdout.write(text2 + "\n");
+  }
+}
+function maybeStack(err, verbose) {
+  if (verbose && err instanceof Error && err.stack !== void 0) {
+    process.stderr.write(err.stack + "\n");
+  }
+}
+function failUnexpected(err, verbose) {
+  if (err instanceof Error) {
+    process.stderr.write((verbose && err.stack !== void 0 ? err.stack : err.message) + "\n");
+  } else {
+    process.stderr.write(String(err) + "\n");
+  }
+  process.exit(1);
+}
+function createProgram() {
+  const program = new import_commander.Command();
+  program.name("plune").description("Plune \u2014 AI-powered assertion testing CLI").version(pkg.version);
+  program.option("-c, --config <path>", "Path to plune.yaml config file (applies to all commands)").option("-v, --verbose", "Verbose output, including stack traces on unexpected errors", false).option("--no-color", "Disable colored output regardless of TTY");
+  program.command("run").description("Run assertions against a dataset").option("--dry-run", "Estimate cost/tokens; do not call the model", false).option("--config <path>", "Path to plune.yaml config file").option(
+    "--only <selector>",
+    "Run a subset by eval id or tag (repeatable)",
+    (val, prev) => [...prev, val],
+    []
+  ).option("--concurrency <n>", "Override provider concurrency", (v) => parseInt(v, 10)).option("--no-cache", "Bypass the local cache for this run").option("--bail", "Stop after the first failing eval", false).option("--format <fmt>", "console | json | markdown", "console").option("-o, --output <path>", "Write the report to a file instead of stdout").action(
+    async (options, command) => {
+      const globals = command.optsWithGlobals();
+      const configPath = globals.config;
+      const [
+        { loadEnv: loadEnv2 },
+        { handleRun: handleRun2 },
+        { exitCodeFor: exitCodeFor2, RunConfigError: RunConfigError2 },
+        { renderReport: renderReport2 },
+        { ConfigNotFoundError: ConfigNotFoundError2, ConfigValidationError: ConfigValidationError2, YamlParseError: YamlParseError2 },
+        { AuthError: AuthError2 }
+      ] = await Promise.all([
+        Promise.resolve().then(() => (init_env(), env_exports)),
+        Promise.resolve().then(() => (init_run2(), run_exports)),
+        Promise.resolve().then(() => (init_orchestrator(), orchestrator_exports)),
+        Promise.resolve().then(() => (init_reporters(), reporters_exports)),
+        Promise.resolve().then(() => (init_errors(), errors_exports)),
+        Promise.resolve().then(() => (init_errors2(), errors_exports2))
+      ]);
+      loadEnv2(configPath !== void 0 ? (0, import_node_path.dirname)((0, import_node_path.resolve)(configPath)) : process.cwd());
+      try {
+        const result = await handleRun2({
+          dryRun: options.dryRun,
+          ...configPath !== void 0 ? { configPath } : {},
+          ...options.only.length > 0 ? { only: options.only } : {},
+          ...typeof options.concurrency === "number" && Number.isFinite(options.concurrency) ? { concurrency: options.concurrency } : {},
+          noCache: options.cache === false,
+          bail: options.bail
+        });
+        if (options.only.length > 0 && result.evals.length === 0) {
+          process.stderr.write("No evals matched the selector.\n");
+        }
+        const text2 = renderReport2(result, toFormat(options.format), {
+          color: globals.color !== false && shouldColor(options.output)
+        });
+        writeReport(text2, options.output);
+        process.exitCode = exitCodeFor2(result);
+      } catch (err) {
+        const verbose = globals.verbose === true;
+        if (err instanceof ConfigValidationError2) {
+          process.stderr.write(err.message + "\n");
+          for (const issue of err.issues) {
+            process.stderr.write(`  - ${issue}
+`);
+          }
+          maybeStack(err, verbose);
+          process.exit(2);
+          return;
+        }
+        if (err instanceof ConfigNotFoundError2 || err instanceof YamlParseError2) {
+          process.stderr.write(err.message + "\n");
+          maybeStack(err, verbose);
+          process.exit(2);
+          return;
+        }
+        if (err instanceof AuthError2) {
+          process.stderr.write(err.message + "\n");
+          maybeStack(err, verbose);
+          process.exit(2);
+          return;
+        }
+        if (err instanceof RunConfigError2) {
+          process.stderr.write(err.message + "\n");
+          maybeStack(err, verbose);
+          process.exit(2);
+          return;
+        }
+        failUnexpected(err, verbose);
+      }
+    }
+  );
+  program.command("report").description("Render the most recent run in a chosen format").option("--format <fmt>", "console | json | markdown", "console").option("-o, --output <path>", "Write the report to a file instead of stdout").action(async (options, command) => {
+    const globals = command.optsWithGlobals();
+    const [{ loadEnv: loadEnv2 }, { handleReport: handleReport2, ReportNotFoundError: ReportNotFoundError2 }, { renderReport: renderReport2 }] = await Promise.all([
+      Promise.resolve().then(() => (init_env(), env_exports)),
+      Promise.resolve().then(() => (init_report(), report_exports)),
+      Promise.resolve().then(() => (init_reporters(), reporters_exports))
+    ]);
+    const cwd = globals.config !== void 0 ? (0, import_node_path.dirname)((0, import_node_path.resolve)(globals.config)) : process.cwd();
+    loadEnv2(cwd);
+    try {
+      const result = handleReport2({ cwd });
+      const text2 = renderReport2(result, toFormat(options.format), {
+        color: globals.color !== false && shouldColor(options.output)
+      });
+      writeReport(text2, options.output);
+    } catch (err) {
+      if (err instanceof ReportNotFoundError2) {
+        process.stderr.write(err.message + "\n");
+        process.exit(2);
+        return;
+      }
+      failUnexpected(err, globals.verbose === true);
+    }
+  });
+  program.command("diff").description("Compare two `plune run --format json` outputs and report regressions").argument("<baseline>", "Path to the baseline run JSON (e.g. from main)").argument("<current>", "Path to the current run JSON (e.g. from the PR)").option("--format <fmt>", "console | json | markdown", "console").option("--fail-on-regression", "Exit 1 when a pass\u2192fail regression is detected", false).option("-o, --output <path>", "Write the diff to a file instead of stdout").action(
+    async (baseline, current, options, command) => {
+      const verbose = command.optsWithGlobals().verbose === true;
+      const [{ handleDiff: handleDiff2, DiffInputError: DiffInputError2 }, { renderDiff: renderDiff2 }] = await Promise.all([
+        Promise.resolve().then(() => (init_diff2(), diff_exports)),
+        Promise.resolve().then(() => (init_diff3(), diff_exports2))
+      ]);
+      try {
+        const diff = handleDiff2({ baselinePath: baseline, currentPath: current });
+        writeReport(renderDiff2(diff, toFormat(options.format)), options.output);
+        process.exitCode = options.failOnRegression && diff.summary.hasRegression ? 1 : 0;
+      } catch (err) {
+        if (err instanceof DiffInputError2) {
+          process.stderr.write(err.message + "\n");
+          maybeStack(err, verbose);
+          process.exit(2);
+          return;
+        }
+        failUnexpected(err, verbose);
+      }
+    }
+  );
+  program.command("init").description("Scaffold plune.yaml (interactive), an example dataset, and .env.example").option("--force", "Overwrite existing files instead of skipping them", false).option("--yes", "Non-interactive: scaffold defaults without prompts (for CI)", false).action(async (options, command) => {
+    const verbose = command.optsWithGlobals().verbose === true;
+    const [{ initCommand: initCommand2 }, { NonTtyError: NonTtyError2 }] = await Promise.all([
+      Promise.resolve().then(() => (init_init(), init_exports)),
+      Promise.resolve().then(() => (init_errors(), errors_exports))
+    ]);
+    try {
+      await initCommand2({ cwd: process.cwd(), force: options.force, yes: options.yes });
+    } catch (err) {
+      if (err instanceof NonTtyError2) {
+        process.stderr.write(err.message + "\n");
+        process.exit(1);
+        return;
+      }
+      failUnexpected(err, verbose);
+    }
+  });
+  program.on("command:*", (operands) => {
+    process.stderr.write(`Unknown command: ${operands.join(" ")}
+`);
+    process.exit(2);
+  });
+  return program;
+}
+var isMain = process.argv[1] === (0, import_node_url.fileURLToPath)(importMetaUrl);
+if (isMain) {
+  createProgram().parseAsync(process.argv).catch((err) => {
+    process.stderr.write(String(err) + "\n");
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProgram
+});