@plune-ai/cli 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1502 @@
+"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 __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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  run: () => handleRun
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/cli/commands/run.ts
+var fs5 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+
+// src/config/loader.ts
+var fs2 = __toESM(require("fs/promises"), 1);
+var import_yaml = require("yaml");
+
+// 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;
+}
+
+// src/config/errors.ts
+var ConfigNotFoundError = class extends Error {
+  code = "CFG_NOT_FOUND";
+  constructor(message) {
+    super(message);
+    this.name = "ConfigNotFoundError";
+  }
+};
+var YamlParseError = class extends Error {
+  code = "YAML_PARSE_ERROR";
+  constructor(message) {
+    super(message);
+    this.name = "YamlParseError";
+  }
+};
+var ConfigValidationError = class extends Error {
+  code = "CONFIG_VALIDATION_ERROR";
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "ConfigValidationError";
+    this.issues = issues;
+  }
+};
+
+// src/config/discover.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var FILENAME = "plune.yaml";
+var MAX_STEPS = 50;
+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 = path.join(dir, FILENAME);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+    steps++;
+  }
+  throw new ConfigNotFoundError(
+    `No ${FILENAME} found. Run "plune init" to create one.`
+  );
+}
+
+// src/config/schema.ts
+var import_zod = require("zod");
+var 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()
+});
+var modelPriceSchema = import_zod.z.object({
+  input_per_1k_usd: import_zod.z.number().nonnegative(),
+  output_per_1k_usd: import_zod.z.number().nonnegative()
+});
+var pricingSchema = import_zod.z.record(modelPriceSchema);
+var 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()
+});
+var datasetRefSchema = import_zod.z.union([
+  import_zod.z.string().min(1),
+  import_zod.z.object({ examples: import_zod.z.array(datasetRowSchema).min(1) })
+]);
+var 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()
+});
+var containsAssertionSchema = import_zod.z.object({
+  type: import_zod.z.literal("contains"),
+  value: import_zod.z.string(),
+  ignore_case: import_zod.z.boolean().optional()
+});
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var assertionConfigSchema = import_zod.z.discriminatedUnion("type", [
+  exactMatchAssertionSchema,
+  containsAssertionSchema,
+  containsAnyAssertionSchema,
+  containsAllAssertionSchema,
+  jsonSchemaAssertionSchema,
+  llmJudgeAssertionSchema,
+  semanticSimilarityAssertionSchema,
+  faithfulnessAssertionSchema,
+  answerRelevanceAssertionSchema,
+  contextPrecisionAssertionSchema
+]);
+var 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" }
+);
+var 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);
+}
+
+// src/providers/anthropic.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+
+// src/providers/errors.ts
+var NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "ECONNREFUSED",
+  "EPIPE",
+  "ENOTFOUND",
+  "EAI_AGAIN"
+]);
+var AuthError = class extends Error {
+  code = "PROVIDER_AUTH";
+  envVar;
+  constructor(message, envVar) {
+    super(message);
+    this.name = "AuthError";
+    this.envVar = envVar;
+  }
+};
+var ProviderError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ProviderError";
+    this.code = code;
+  }
+};
+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));
+}
+
+// src/providers/retry.ts
+var defaultSleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
+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;
+    }
+  }
+}
+
+// src/providers/prices.ts
+var 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;
+}
+var defaultWarn = (message) => {
+  process.stderr.write(message + "\n");
+};
+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;
+}
+
+// src/providers/anthropic.ts
+var ENV_VAR = "ANTHROPIC_API_KEY";
+var DEFAULT_MAX_RETRIES = 2;
+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) };
+    }
+  };
+}
+
+// src/providers/openai.ts
+var import_openai = __toESM(require("openai"), 1);
+var DEFAULT_MAX_RETRIES2 = 2;
+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" });
+}
+
+// src/providers/openrouter.ts
+var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+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)
+  });
+}
+
+// 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);
+}
+
+// src/providers/mock.ts
+function makeMockProvider() {
+  return {
+    complete: () => Promise.resolve({
+      output: "mock response",
+      usage: { input_tokens: 10, output_tokens: 5 }
+    }),
+    estimateCost: () => ({ cost_usd: 0 })
+  };
+}
+
+// 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;
+}
+
+// src/embeddings/embedder.ts
+var MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+var 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;
+  }
+};
+var defaultEmbedder;
+function getDefaultEmbedder() {
+  return defaultEmbedder ??= new XenovaEmbedder();
+}
+
+// src/cache/cache.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var SCHEMA_VERSION = 1;
+var META_DDL = "CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);";
+var 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);";
+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 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();
+  }
+};
+var NoOpCache = class {
+  get() {
+    return void 0;
+  }
+  set() {
+  }
+  clear() {
+  }
+  close() {
+  }
+};
+
+// src/orchestrator/run.ts
+var fs3 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+
+// src/util/hash.ts
+var import_node_crypto = require("crypto");
+
+// 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));
+}
+
+// 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));
+}
+
+// src/assertions/interpolate.ts
+var PLACEHOLDER = /\{\{\s*([\w.]+)\s*\}\}/g;
+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;
+  });
+}
+
+// src/assertions/exact-match.ts
+var 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 = {
+  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}"` }
+    );
+  }
+};
+var 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)}` }
+    );
+  }
+};
+var 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-schema.ts
+var import_ajv = require("ajv");
+
+// 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;
+}
+
+// src/assertions/json-schema.ts
+var 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 = 0.8;
+var 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 text = await judge.ask(prompt5);
+  const result = extractJson(text, "auto");
+  if (!result.ok) {
+    throw new Error(`judge returned no parseable JSON (got: ${text.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");
+}
+
+// src/assertions/llm-judge.ts
+var DEFAULT_PASS_THRESHOLD = 0.5;
+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 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
+var DEFAULT_THRESHOLD2 = 0.7;
+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 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
+var DEFAULT_THRESHOLD3 = 0.7;
+function prompt3(output) {
+  return `Generate the questions that the OUTPUT directly and fully answers. Respond ONLY with JSON: {"questions": ["<question>", ...]}.
+
+OUTPUT:
+${output}`;
+}
+var 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
+var DEFAULT_THRESHOLD4 = 0.7;
+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 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;
+}
+var defaultRegistry;
+function getAssertion(type) {
+  defaultRegistry ??= createDefaultRegistry2();
+  return defaultRegistry.resolve(type);
+}
+
+// src/orchestrator/judge.ts
+var DEFAULT_MAX_TOKENS = 1024;
+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;
+    }
+  };
+}
+
+// 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;
+}
+
+// src/orchestrator/run.ts
+var DEFAULT_MAX_TOKENS2 = 1024;
+var PLUNE_VERSION = "0.1.0";
+var RunConfigError = class extends Error {
+  code = "CONFIG_ERROR";
+  constructor(message) {
+    super(message);
+    this.name = "RunConfigError";
+  }
+};
+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(path2.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
+  };
+}
+
+// src/orchestrator/dataset.ts
+var fs4 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+function loadDataset(ref, baseDir) {
+  if (typeof ref !== "string") {
+    return ref.examples;
+  }
+  const content = fs4.readFileSync(path3.resolve(baseDir, ref), "utf8");
+  return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => JSON.parse(line));
+}
+
+// src/cli/commands/run.ts
+var NOOP_CACHE = { get: () => void 0, set: () => {
+}, clear: () => {
+}, close: () => {
+} };
+function isMockMode(env) {
+  return env["PLUNE_MOCK_PROVIDER"] === "1";
+}
+function buildRealDeps(config, baseDir, dryRun) {
+  const dir = path4.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(path4.join(dir, "cache.db")),
+    now: Date.now,
+    loadDataset,
+    baseDir
+  };
+}
+function persist(result, baseDir) {
+  const dir = path4.join(baseDir, ".plune");
+  fs5.mkdirSync(dir, { recursive: true });
+  fs5.writeFileSync(path4.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 ? path4.dirname(path4.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();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});