@plune-ai/cli 0.26.0 → 0.28.0

package/dist/index.d.ts

@@ -15,6 +15,24 @@ interface Summary {
     skipped?: number;
     cost_usd: number;
     duration_ms: number;
+    /** plune-ai/plune#1696. Where the answers came from. Optional and additive; absent in older runs. */
+    cache?: CacheSummary;
+}
+/**
+ * `from_cache` rows were answered by the store, `from_model` by a model call, `missed` had no entry
+ * under `--cache-strict` and were not answered. The `saved` totals are the sum of the rows' `cache_saved`.
+ */
+interface CacheSummary {
+    from_cache: number;
+    from_model: number;
+    missed: number;
+    /** Rows the provider failed on: answered by neither, so the four counts add up to `total` (dry-run rows aside). */
+    errored: number;
+    saved: {
+        input_tokens: number;
+        output_tokens: number;
+        cost_usd: number;
+    };
 }
 interface AssertionResultRecord {
     type: string;
@@ -87,6 +105,12 @@ interface RowResult {
     latency_ms?: number;
     error?: RunError;
     assertions: AssertionResultRecord[];
+    /** plune-ai/plune#1696. On a cache hit: what the call would have cost. Optional and additive. */
+    cache_saved?: {
+        input_tokens: number;
+        output_tokens: number;
+        cost_usd: number;
+    };
     /**
      * ADR 0045. Say it when the test was never judged, rather than letting `failed` stand for both
      * "the environment broke" and "the code is wrong".
@@ -231,6 +255,11 @@ interface CompletionResponse {
      * estimated downstream (ADR-PRC02). Additive + optional: existing providers omit it.
      */
     cost_usd?: number;
+    /**
+     * Why the model stopped, normalised: `length` (hit the token limit), `error` or `content_filter`
+     * mark an answer the cache must not keep. Absent when the provider does not say. Optional and additive.
+     */
+    finish_reason?: string;
 }
 interface CostEstimate {
     cost_usd: number;
@@ -260,6 +289,10 @@ interface Cache {
         maxAgeMs?: number;
     }): CompletionResponse | undefined;
     set(key: string, value: CompletionResponse): void;
+    /** Remove one entry (a cached answer that turned out unusable). Best-effort. */
+    delete(key: string): void;
+    /** Entries left by an older policy version, found when the store was opened (0 when none or unknown). */
+    readonly staleEntries?: number;
     clear(): void;
     close(): void;
 }
@@ -280,6 +313,9 @@ interface RunOptions {
     concurrency?: number;
     noCache?: boolean;
     bail?: boolean;
+    cacheStrict?: boolean;
+    /** Milliseconds; parsed from `--cache-max-age` by the caller. */
+    cacheMaxAgeMs?: number;
 }
 declare function handleRun(options: RunOptions, depsFactory?: (config: Config, baseDir: string) => RunDeps): Promise<RunResult>;
 
@@ -449,6 +485,17 @@ declare const runResultSchema: z.ZodObject<{
         skipped: z.ZodOptional<z.ZodNumber>;
         cost_usd: z.ZodNumber;
         duration_ms: z.ZodNumber;
+        cache: z.ZodOptional<z.ZodObject<{
+            from_cache: z.ZodNumber;
+            from_model: z.ZodNumber;
+            missed: z.ZodNumber;
+            errored: z.ZodNumber;
+            saved: z.ZodObject<{
+                input_tokens: z.ZodNumber;
+                output_tokens: z.ZodNumber;
+                cost_usd: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
     evals: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -477,6 +524,11 @@ declare const runResultSchema: z.ZodObject<{
                     passed: z.ZodBoolean;
                 }, z.core.$strip>>>;
             }, z.core.$strip>>;
+            cache_saved: z.ZodOptional<z.ZodObject<{
+                input_tokens: z.ZodNumber;
+                output_tokens: z.ZodNumber;
+                cost_usd: z.ZodNumber;
+            }, z.core.$strip>>;
             inconclusive: z.ZodOptional<z.ZodEnum<{
                 blocked: "blocked";
                 skipped: "skipped";

package/dist/index.js

@@ -452,7 +452,8 @@ function makeAnthropicProvider(config, env, pricing) {
           usage: {
             input_tokens: res.usage.input_tokens,
             output_tokens: res.usage.output_tokens
-          }
+          },
+          ...res.stop_reason === "max_tokens" ? { finish_reason: "length" } : res.stop_reason !== null && res.stop_reason !== void 0 ? { finish_reason: res.stop_reason } : {}
         };
       } catch (err) {
         throw normalizeProviderError(err, apiKey, ENV_VAR);
@@ -499,8 +500,11 @@ function makeOpenAiCompatibleProvider(opts) {
           { max_retries: maxRetries }
         );
         const reportedCost = reportsCost ? res.usage?.cost : void 0;
+        const choice = res.choices[0];
+        const finish = choice?.error !== void 0 ? "error" : choice?.finish_reason;
         return {
-          output: res.choices[0]?.message?.content ?? "",
+          output: choice?.message?.content ?? "",
+          ...typeof finish === "string" ? { finish_reason: finish } : {},
           usage: {
             input_tokens: res.usage?.prompt_tokens ?? 0,
             output_tokens: res.usage?.completion_tokens ?? 0
@@ -635,12 +639,94 @@ function getDefaultEmbedder() {
 }
 
 // src/cache/cache.ts
-import Database from "better-sqlite3";
+import { createRequire } from "module";
+
+// src/util/hash.ts
+import { createHash } from "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 createHash("sha256").update(input, "utf8").digest("hex");
+}
+var CACHE_POLICY_VERSION = 1;
+function cacheKey(inputs, policyVersion = CACHE_POLICY_VERSION) {
+  const { provider, model, temperature, max_tokens, prompt_resolved } = inputs;
+  return sha256(
+    canonicalJson({ provider, model, temperature, max_tokens, prompt_resolved, policy: policyVersion })
+  );
+}
+function configHash(config) {
+  return sha256(canonicalJson(config));
+}
+
+// src/cache/cache.ts
 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);";
+var UNCACHEABLE_FINISH = /* @__PURE__ */ new Set(["length", "max_tokens", "error", "content_filter", "pause_turn"]);
+function isCacheable(res) {
+  if (res.output.trim() === "") return false;
+  return res.finish_reason === void 0 || !UNCACHEABLE_FINISH.has(res.finish_reason);
+}
+var missingNoted = false;
+function loadDatabase() {
+  try {
+    return createRequire(import.meta.url)("better-sqlite3");
+  } catch {
+    if (!missingNoted) {
+      missingNoted = true;
+      console.error(
+        "plune: completion cache disabled (better-sqlite3 is not installed or failed to load). Reinstall with a C++ toolchain and Python available, or ignore: runs work without the cache."
+      );
+    }
+    return void 0;
+  }
+}
 function openCache(file, opts = {}) {
   const now = opts.now ?? Date.now;
+  const Database = loadDatabase();
+  if (Database === void 0) return new NoOpCache();
   try {
     const db = new Database(file);
     try {
@@ -649,7 +735,14 @@ function openCache(file, opts = {}) {
       db.close();
       throw err;
     }
-    return new SqliteCache(db, now);
+    let stale;
+    try {
+      stale = markPolicy(db, opts.policyVersion ?? CACHE_POLICY_VERSION);
+    } catch (err) {
+      db.close();
+      throw err;
+    }
+    return new SqliteCache(db, now, stale);
   } catch {
     return new NoOpCache();
   }
@@ -664,17 +757,33 @@ function ensureSchema(db) {
     db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run("schema_version", current);
   }
 }
+function markPolicy(db, version) {
+  const current = String(version);
+  const stored = db.prepare("SELECT value FROM meta WHERE key = 'policy_version'").get()?.value;
+  if (stored === current) return 0;
+  return db.transaction(() => {
+    const { n } = db.prepare("SELECT COUNT(*) AS n FROM completions").get();
+    db.exec("DELETE FROM completions");
+    db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run("policy_version", current);
+    return n;
+  })();
+}
 var SqliteCache = class {
-  constructor(db, now) {
+  constructor(db, now, staleEntries) {
     this.db = db;
     this.now = now;
+    this.staleEntries = staleEntries;
   }
   db;
   now;
+  staleEntries;
   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 (typeof row.output !== "string" || !Number.isFinite(row.input_tokens) || !Number.isFinite(row.output_tokens) || !Number.isFinite(row.created_at)) {
+        return void 0;
+      }
       if (opts.maxAgeMs !== void 0 && this.now() - row.created_at > opts.maxAgeMs) {
         return void 0;
       }
@@ -700,6 +809,12 @@ var SqliteCache = class {
     } catch {
     }
   }
+  delete(key) {
+    try {
+      this.db.prepare("DELETE FROM completions WHERE cache_key = ?").run(key);
+    } catch {
+    }
+  }
   clear() {
     try {
       this.db.exec("DELETE FROM completions");
@@ -716,6 +831,8 @@ var NoOpCache = class {
   }
   set() {
   }
+  delete() {
+  }
   clear() {
   }
   close() {
@@ -726,60 +843,72 @@ var NoOpCache = class {
 import * as fs3 from "fs";
 import * as path2 from "path";
 
-// src/util/hash.ts
-import { createHash } from "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");
+// src/assertions/json-extract.ts
+function extractJson(output, mode) {
+  if (mode === "strict") {
+    return tryParse(output.trim());
   }
-  if (Array.isArray(value)) {
-    return value.map(normalizeValue);
+  const fenced = extractFencedBlock(output);
+  if (fenced !== null) {
+    const r = tryParse(fenced);
+    if (r.ok) return r;
   }
-  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;
+  for (const run of balancedRuns(output)) {
+    const r = tryParse(run);
+    if (r.ok) return r;
   }
-  throw new Error(
-    `canonicalJson: unsupported value type: ${typeof value}`
-  );
+  return { ok: false };
 }
-function canonicalJson(value) {
-  return JSON.stringify(normalizeValue(value));
+function tryParse(s) {
+  try {
+    return { ok: true, value: JSON.parse(s) };
+  } catch {
+    return { ok: false };
+  }
 }
-
-// src/util/hash.ts
-function sha256(input) {
-  return createHash("sha256").update(input, "utf8").digest("hex");
+function extractFencedBlock(s) {
+  const m = s.match(/```(?:json)?\s*\n?([\s\S]*?)```/i);
+  return m?.[1]?.trim() ?? null;
 }
-function cacheKey(inputs) {
-  const { provider, model, temperature, max_tokens, prompt_resolved } = inputs;
-  return sha256(canonicalJson({ provider, model, temperature, max_tokens, prompt_resolved }));
+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 configHash(config) {
-  return sha256(canonicalJson(config));
+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/interpolate.ts
@@ -855,76 +984,6 @@ var containsAll = {
 
 // src/assertions/json-schema.ts
 import { Ajv } from "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";
@@ -1284,6 +1343,12 @@ var RunConfigError = class extends Error {
     this.name = "RunConfigError";
   }
 };
+var CACHE_MISS_CODE = "CACHE_MISS";
+function answerParses(output, assertions) {
+  return assertions.every(
+    (a) => a.type !== "json-schema" || extractJson(output, a.extract ?? "auto").ok
+  );
+}
 function resolvePrompt(template, vars) {
   return template.replace(/\{\{\s*(\w+)\s*\}\}/g, (_match, key) => {
     if (!(key in vars)) {
@@ -1311,17 +1376,35 @@ async function runRow(p) {
     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: temperature ?? 0,
-    max_tokens: maxTokens,
-    prompt_resolved: prompt5
-  });
+  const key = cacheKey(
+    {
+      provider: p.providerConfig.type,
+      model: p.providerConfig.model,
+      temperature: temperature ?? 0,
+      max_tokens: maxTokens,
+      prompt_resolved: prompt5
+    },
+    p.policyVersion
+  );
   let output;
   let usage;
   let cached = false;
-  const hit = p.noCache ? void 0 : p.cache.get(key);
+  let cacheSaved;
+  let hit = p.noCache ? void 0 : p.cache.get(key, p.cacheMaxAgeMs !== void 0 ? { maxAgeMs: p.cacheMaxAgeMs } : {});
+  if (hit !== void 0 && !answerParses(hit.output, p.assertions)) {
+    if (p.cacheStrict !== true) p.cache.delete(key);
+    hit = void 0;
+  }
+  if (hit === void 0 && p.cacheStrict === true) {
+    return {
+      vars: p.row.vars,
+      output: null,
+      cached: false,
+      latency_ms: p.now() - t0,
+      error: { code: CACHE_MISS_CODE, message: "no usable cache entry (--cache-strict)" },
+      assertions: []
+    };
+  }
   if (hit !== void 0) {
     output = hit.output;
     cached = true;
@@ -1330,6 +1413,11 @@ async function runRow(p) {
       output_tokens: hit.usage.output_tokens,
       cost_usd: 0
     };
+    cacheSaved = {
+      input_tokens: hit.usage.input_tokens,
+      output_tokens: hit.usage.output_tokens,
+      cost_usd: p.provider.estimateCost(hit.usage).cost_usd
+    };
   } else {
     try {
       const res = await p.provider.complete({
@@ -1347,7 +1435,9 @@ async function runRow(p) {
         // 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);
+      if (!p.noCache && isCacheable(res) && answerParses(res.output, p.assertions)) {
+        p.cache.set(key, res);
+      }
     } catch (err) {
       return {
         vars: p.row.vars,
@@ -1393,6 +1483,7 @@ async function runRow(p) {
     cached,
     usage: finalUsage,
     latency_ms: p.now() - t0,
+    ...cacheSaved !== void 0 ? { cache_saved: cacheSaved } : {},
     ...assertionError !== void 0 ? { error: assertionError } : {},
     assertions: records
   };
@@ -1427,19 +1518,41 @@ function summarize(evals, durationMs) {
     cost_usd: 0,
     duration_ms: durationMs
   };
+  const cache = {
+    from_cache: 0,
+    from_model: 0,
+    missed: 0,
+    errored: 0,
+    saved: { input_tokens: 0, output_tokens: 0, cost_usd: 0 }
+  };
   for (const ev of evals) {
     for (const row of ev.rows) {
       summary.total += 1;
       summary[rowStatus(row)] += 1;
       summary.cost_usd += row.usage?.cost_usd ?? 0;
+      if (row.cached) {
+        cache.from_cache += 1;
+        cache.saved.input_tokens += row.cache_saved?.input_tokens ?? 0;
+        cache.saved.output_tokens += row.cache_saved?.output_tokens ?? 0;
+        cache.saved.cost_usd += row.cache_saved?.cost_usd ?? 0;
+      } else if (row.error?.code === CACHE_MISS_CODE) cache.missed += 1;
+      else if (row.output !== null) cache.from_model += 1;
+      else if (row.error !== void 0) cache.errored += 1;
     }
   }
-  return summary;
+  return { ...summary, cache };
 }
 async function runOrchestration(config, options, deps) {
+  const noCache = options.noCache ?? false;
+  const cacheStrict = options.cacheStrict ?? false;
+  if (noCache && cacheStrict) {
+    throw new RunConfigError("--no-cache and --cache-strict cannot be used together");
+  }
+  if (noCache && options.cacheMaxAgeMs !== void 0) {
+    throw new RunConfigError("--no-cache and --cache-max-age cannot be used together");
+  }
   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);
@@ -1466,7 +1579,9 @@ async function runOrchestration(config, options, deps) {
         cache: deps.cache,
         now: deps.now,
         dryRun,
-        noCache
+        noCache,
+        cacheStrict,
+        ...options.cacheMaxAgeMs !== void 0 ? { cacheMaxAgeMs: options.cacheMaxAgeMs } : {}
       })
     );
     const passed = rowResults.every((r) => rowStatus(r) === "passed");
@@ -1499,6 +1614,7 @@ function loadDataset(ref, baseDir) {
 
 // src/cli/commands/run.ts
 var NOOP_CACHE = { get: () => void 0, set: () => {
+}, delete: () => {
 }, clear: () => {
 }, close: () => {
 } };
@@ -1535,6 +1651,11 @@ async function handleRun(options, depsFactory) {
   const factory = depsFactory ?? ((c, d) => buildRealDeps(c, d, options.dryRun));
   const deps = factory(config, baseDir);
   try {
+    const stale = deps.cache.staleEntries ?? 0;
+    if (stale > 0) {
+      process.stderr.write(`cache policy changed, ${stale} entries are stale (dropped)
+`);
+    }
     const result = await runOrchestration(
       config,
       {
@@ -1542,7 +1663,9 @@ async function handleRun(options, depsFactory) {
         ...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 } : {}
+        ...options.bail !== void 0 ? { bail: options.bail } : {},
+        ...options.cacheStrict === true ? { cacheStrict: true } : {},
+        ...options.cacheMaxAgeMs !== void 0 ? { cacheMaxAgeMs: options.cacheMaxAgeMs } : {}
       },
       deps
     );
@@ -1589,6 +1712,7 @@ var rowResultSchema = z3.object({
   latency_ms: z3.number().optional(),
   error: runErrorSchema.optional(),
   assertions: z3.array(assertionResultRecordSchema2),
+  cache_saved: z3.object({ input_tokens: z3.number(), output_tokens: z3.number(), cost_usd: z3.number() }).optional(),
   /** ADR 0045. Optional and additive — the same enum the platform validates on `POST /v1/runs`. */
   inconclusive: z3.enum(ROW_INCONCLUSIVE).optional()
 });
@@ -1601,7 +1725,14 @@ var summarySchema = z3.object({
   blocked: z3.number().optional(),
   skipped: z3.number().optional(),
   cost_usd: z3.number(),
-  duration_ms: z3.number()
+  duration_ms: z3.number(),
+  cache: z3.object({
+    from_cache: z3.number(),
+    from_model: z3.number(),
+    missed: z3.number(),
+    errored: z3.number(),
+    saved: z3.object({ input_tokens: z3.number(), output_tokens: z3.number(), cost_usd: z3.number() })
+  }).optional()
 });
 var evalResultSchema = z3.object({
   id: z3.string(),

package/dist/reporter-core.cjs

@@ -316,6 +316,7 @@ function shardOf(env) {
 }
 var UPLOAD_CONCURRENCY = { min: 1, max: 32, default: 16 };
 var UPLOAD_RETRIES = { min: 0, max: 20, default: 6 };
+var IMPORT_TIMEOUT = { min: 0, max: 86400, default: 600 };
 function value(env, name) {
   const raw = env[name]?.trim();
   return raw === void 0 || raw === "" ? void 0 : raw;
@@ -353,6 +354,7 @@ function readEnv(env = process.env) {
   const warnings = [];
   const uploadConcurrency = bounded(env, "PLUNE_UPLOAD_CONCURRENCY", UPLOAD_CONCURRENCY, warnings);
   const uploadRetries = bounded(env, "PLUNE_UPLOAD_RETRIES", UPLOAD_RETRIES, warnings);
+  const importTimeout = bounded(env, "PLUNE_IMPORT_TIMEOUT", IMPORT_TIMEOUT, warnings);
   const title = value(env, "PLUNE_RUN_TITLE");
   const environment = value(env, "PLUNE_ENV");
   const labels = list(env, "PLUNE_LABELS");
@@ -384,6 +386,7 @@ function readEnv(env = process.env) {
     keepOpen: flag(env, "PLUNE_SHARED_RUN") || flag(env, "PLUNE_PROCEED") || shard !== void 0 || shardError !== void 0,
     ...shard !== void 0 ? { shard } : {},
     ...shardError !== void 0 ? { shardError } : {},
+    ...importTimeout !== void 0 ? { importTimeout } : {},
     ignored: UNSUPPORTED_VARS.filter((name) => value(env, name) !== void 0),
     warnings
   };