@plune-ai/cli 0.21.0 → 0.23.0

package/dist/reporter-core.d.ts

@@ -326,6 +326,10 @@ interface ReporterConfig {
     labels?: string[];
     /** Results per request. The platform's ceiling is 500. */
     batchSize?: number;
+    /** Files in flight at once (`PLUNE_UPLOAD_CONCURRENCY`, 1 to 32, default 4). */
+    uploadConcurrency?: number;
+    /** Retries of a request the platform or a bucket asked to wait for (`PLUNE_UPLOAD_RETRIES`, 0 to 20, default 6). */
+    uploadRetries?: number;
     /** Where unsent batches go. Defaults beside the run file the CLI already writes. */
     fallbackPath?: string;
     /**
@@ -427,6 +431,8 @@ interface EnvSettings {
     keepOpen: boolean;
     /** Variables that were set and have nowhere to land. The caller says so once. */
     ignored: string[];
+    /** Variables that were set to something unusable and fell back to their default. The caller says so once. */
+    warnings: string[];
 }
 declare function readEnv(env?: NodeJS.ProcessEnv): EnvSettings;
 /**
@@ -582,9 +588,18 @@ interface ClientOptions {
     fetchImpl?: typeof fetch;
     /** Test seam — the same idea as `fetchImpl`, so a retry test costs milliseconds, not seconds. */
     wait?: (ms: number) => Promise<void>;
+    /** Retries of a file's requests (default 2 for the platform's, 3 for a bucket's): what `uploadRetries` is. */
+    uploadRetries?: number;
+    /** Test seam for the jitter: a number in [0, 1). */
+    random?: () => number;
+    /** Test seam for the clock the shared pause is read against. */
+    now?: () => number;
+    /** Called once for every retry that is about to wait. */
+    onRetry?: () => void;
 }
 interface PlatformClient {
-    post<T>(path: string, body: unknown): Promise<ClientOutcome<T>>;
+    /** `retries` after the first try: the default is 2; a file's requests ask for more. */
+    post<T>(path: string, body: unknown, retries?: number): Promise<ClientOutcome<T>>;
     /**
      * A file's bytes as the body, under the file's own type (platform ADR 0040) — not JSON. Through the
      * same retries as a POST, so a 429 on the platform's upload limit waits out its `Retry-After`.

package/dist/reporter-core.js

@@ -1,5 +1,5 @@
 // src/reporter-core/session.ts
-import { createHash, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID } from "crypto";
 import { promises as disk } from "fs";
 import { basename as basename2, extname } from "path";
 import { TextDecoder } from "util";
@@ -35,7 +35,17 @@ import { createReadStream, openAsBlob } from "fs";
 import { pipeline } from "stream";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
-var RETRY_DELAYS_MS = [300, 900];
+var BACKOFF_BASE_MS = 300;
+var BACKOFF_CAP_MS = 1e4;
+var DEFAULT_RETRIES = 2;
+var RETRY_AFTER_CAP_MS = 6e4;
+function parseRetryAfter(raw, now = Date.now()) {
+  const text = raw?.trim();
+  if (text === void 0 || text === "") return null;
+  const seconds = /^\d+(\.\d+)?$/.test(text) ? Number(text) : (Date.parse(text) - now) / 1e3;
+  if (!Number.isFinite(seconds)) return null;
+  return Math.min(Math.max(seconds, 0) * 1e3, RETRY_AFTER_CAP_MS);
+}
 var IDLE_MS = 3e5;
 function nodeTransport(url, init, idleMs = IDLE_MS) {
   return new Promise((resolve2, reject) => {
@@ -66,7 +76,6 @@ function nodeTransport(url, init, idleMs = IDLE_MS) {
     req.end(init.body);
   });
 }
-var PUT_DELAYS_MS = [500, 1500, 4e3];
 var withoutLength = (headers) => Object.fromEntries(Object.entries(headers).filter(([name]) => name.toLowerCase() !== "content-length"));
 function nodePut(url, headers, source, idleMs) {
   return new Promise((resolve2, reject) => {
@@ -111,12 +120,6 @@ async function detailOf(res) {
     return { detail: "" };
   }
 }
-function retryAfterMs(res) {
-  const raw = res.headers.get("retry-after");
-  if (raw === null) return null;
-  const seconds = Number(raw.trim());
-  return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : null;
-}
 function classify(status) {
   if (status === 401 || status === 403) return "auth";
   if (status === 409) return "conflict";
@@ -127,15 +130,34 @@ function classify(status) {
 function createClient(opts) {
   const doFetch = opts.fetchImpl ?? nodeTransport;
   const wait = opts.wait ?? sleep;
+  const uploadRetries = opts.uploadRetries === void 0 ? void 0 : Math.max(0, Math.floor(opts.uploadRetries));
+  const random = opts.random ?? Math.random;
+  const now = opts.now ?? Date.now;
+  let pausedUntil = 0;
+  const jittered = (ms) => Math.round(ms * (1 + random() * 0.5));
+  async function backOff(attempt, said) {
+    opts.onRetry?.();
+    const ms = jittered(said ?? Math.min(BACKOFF_BASE_MS * 2 ** attempt, BACKOFF_CAP_MS));
+    const until = now() + ms;
+    pausedUntil = Math.max(pausedUntil, until);
+    await wait(ms);
+    return until;
+  }
+  async function respectPause(mine) {
+    const left = pausedUntil - now();
+    if (pausedUntil > mine && left > 0) await wait(left + Math.round(random() * 250));
+  }
   const base = opts.apiUrl.replace(/\/+$/, "");
   const scrub = (text) => opts.token === "" ? text : text.split(opts.token).join("***");
-  async function send(method, path3, payload) {
+  async function send(method, path3, payload, retries = DEFAULT_RETRIES) {
     let last = {
       kind: "unavailable",
       status: null,
       detail: "no attempt was made"
     };
-    for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt += 1) {
+    let mine = 0;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+      await respectPause(mine);
       let res;
       try {
         res = await doFetch(`${base}${path3}`, {
@@ -148,7 +170,8 @@ function createClient(opts) {
         });
       } catch (err) {
         last = { kind: "unavailable", status: null, detail: scrub(String(err)) };
-        if (attempt < RETRY_DELAYS_MS.length) await wait(RETRY_DELAYS_MS[attempt]);
+        if (attempt >= Math.min(retries, DEFAULT_RETRIES)) break;
+        mine = await backOff(attempt, null);
         continue;
       }
       if (res.ok) {
@@ -163,25 +186,28 @@ function createClient(opts) {
       const kind = classify(res.status);
       last = { kind, status: res.status, detail: scrub(said.detail), ...said.code !== void 0 ? { code: said.code } : {} };
       if (kind !== "unavailable") break;
-      if (res.status === 429 && retryAfterMs(res) === null) {
+      const said429 = parseRetryAfter(res.headers.get("retry-after"), now());
+      if (res.status === 429 && said429 === null) {
         last.kind = "invalid";
         last.detail = "quota exceeded (no Retry-After)";
         if (said.detail) last.detail += ` \u2014 ${scrub(said.detail)}`;
         break;
       }
-      if (attempt < RETRY_DELAYS_MS.length) {
-        await wait(retryAfterMs(res) ?? RETRY_DELAYS_MS[attempt]);
-      }
+      if (attempt >= (said429 === null ? Math.min(retries, DEFAULT_RETRIES) : retries)) break;
+      mine = await backOff(attempt, said429);
     }
     return { ok: false, ...last };
   }
   return {
-    post: (path3, body) => send("POST", path3, { body: JSON.stringify(body), type: "application/json" }),
-    upload: (path3, bytes, contentType) => send("POST", path3, { body: bytes, type: contentType }),
+    post: (path3, body, retries) => send("POST", path3, { body: JSON.stringify(body), type: "application/json" }, retries),
+    upload: (path3, bytes, contentType) => send("POST", path3, { body: bytes, type: contentType }, uploadRetries ?? DEFAULT_RETRIES),
     del: (path3) => send("DELETE", path3),
     async put(url, headers, source) {
+      const putRetries = uploadRetries ?? 3;
       let last = { ok: false, status: null, code: "network" };
-      for (let attempt = 0; attempt <= PUT_DELAYS_MS.length; attempt += 1) {
+      let mine = 0;
+      for (let attempt = 0; attempt <= putRetries; attempt += 1) {
+        await respectPause(mine);
         try {
           let status;
           let retryAfter;
@@ -196,15 +222,15 @@ function createClient(opts) {
           if (status >= 200 && status <= 299) return { ok: true };
           last = { ok: false, status, code: `bucket_${status}` };
           if (status < 500 && status !== 429) return last;
-          const seconds = retryAfter === null ? NaN : Number(retryAfter.trim());
-          if (attempt < PUT_DELAYS_MS.length) {
-            await wait(Number.isFinite(seconds) && seconds >= 0 ? Math.min(seconds, 60) * 1e3 : PUT_DELAYS_MS[attempt]);
-          }
+          const said = parseRetryAfter(retryAfter, now());
+          if (attempt >= (said === null ? Math.min(putRetries, 3) : putRetries)) return last;
+          mine = await backOff(attempt, said);
           continue;
         } catch (err) {
           last = { ok: false, status: null, code: codeOfError(err) };
         }
-        if (attempt < PUT_DELAYS_MS.length) await wait(PUT_DELAYS_MS[attempt]);
+        if (attempt >= Math.min(putRetries, 3)) return last;
+        mine = await backOff(attempt, null);
       }
       return last;
     }
@@ -214,6 +240,8 @@ function createClient(opts) {
 // src/reporter-core/env.ts
 import * as path from "path";
 var UNSUPPORTED_VARS = ["PLUNE_GROUP"];
+var UPLOAD_CONCURRENCY = { min: 1, max: 32, default: 4 };
+var UPLOAD_RETRIES = { min: 0, max: 20, default: 6 };
 function value(env, name) {
   const raw = env[name]?.trim();
   return raw === void 0 || raw === "" ? void 0 : raw;
@@ -228,6 +256,14 @@ function count(env, name) {
   const n = Number(raw);
   return Number.isInteger(n) && n > 0 ? n : void 0;
 }
+function bounded(env, name, range, warnings) {
+  const raw = value(env, name);
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  if (/^\d+$/.test(raw) && n >= range.min && n <= range.max) return n;
+  warnings.push(`${name}=${JSON.stringify(raw.slice(0, 40))} is not a whole number from ${range.min} to ${range.max} \u2014 using ${range.default}.`);
+  return void 0;
+}
 function list(env, name) {
   const raw = value(env, name);
   if (raw === void 0) return void 0;
@@ -240,6 +276,9 @@ function readEnv(env = process.env) {
   const apiUrl = value(env, "PLUNE_API_URL");
   const fallbackPath = value(env, "PLUNE_FALLBACK");
   const batchSize = count(env, "PLUNE_BATCH_SIZE");
+  const warnings = [];
+  const uploadConcurrency = bounded(env, "PLUNE_UPLOAD_CONCURRENCY", UPLOAD_CONCURRENCY, warnings);
+  const uploadRetries = bounded(env, "PLUNE_UPLOAD_RETRIES", UPLOAD_RETRIES, warnings);
   const title = value(env, "PLUNE_RUN_TITLE");
   const environment = value(env, "PLUNE_ENV");
   const labels = list(env, "PLUNE_LABELS");
@@ -252,6 +291,8 @@ function readEnv(env = process.env) {
       ...apiUrl !== void 0 ? { apiUrl } : {},
       ...fallbackPath !== void 0 ? { fallbackPath } : {},
       ...batchSize !== void 0 ? { batchSize } : {},
+      ...uploadConcurrency !== void 0 ? { uploadConcurrency } : {},
+      ...uploadRetries !== void 0 ? { uploadRetries } : {},
       ...title !== void 0 ? { title } : {},
       ...environment !== void 0 ? { environment } : {},
       ...labels !== void 0 ? { labels } : {},
@@ -264,7 +305,8 @@ function readEnv(env = process.env) {
     // reporting into this run; `PROCEED` says the job will close it on its own schedule. Either
     // way this process must not be the one to call it finished.
     keepOpen: flag(env, "PLUNE_SHARED_RUN") || flag(env, "PLUNE_PROCEED"),
-    ignored: UNSUPPORTED_VARS.filter((name) => value(env, name) !== void 0)
+    ignored: UNSUPPORTED_VARS.filter((name) => value(env, name) !== void 0),
+    warnings
   };
 }
 function defaultRunTitle(env = process.env, now = /* @__PURE__ */ new Date(), cwd = process.cwd()) {
@@ -428,6 +470,27 @@ function webLink(href) {
   return href !== void 0 && /^https?:\/\//i.test(href) && URL.canParse(href) ? href : void 0;
 }
 
+// src/reporter-core/files-batch.ts
+import { createHash } from "crypto";
+import { createReadStream as createReadStream2 } from "fs";
+var FILES_BATCH_MAX = 100;
+var DIRECT_BATCH_BYTES = 6 * 1024 * 1024;
+var BATCH_PIPELINES = 2;
+async function sha256File(path3) {
+  const hash = createHash("sha256");
+  for await (const part of createReadStream2(path3)) hash.update(part);
+  return hash.digest("hex");
+}
+var sha256Bytes = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var BUCKET_CODES = /* @__PURE__ */ new Set([
+  "bucket_unreachable",
+  "not_connected",
+  "platform_not_configured",
+  "upload_expired",
+  "file_mismatch",
+  "file_missing"
+]);
+
 // src/reporter-core/fallback.ts
 import * as fs from "fs";
 import * as path2 from "path";
@@ -450,7 +513,7 @@ function appendBatch(file, batch) {
 var RESOLVE_CHUNK = 500;
 var BATCH_MAX = 500;
 var DISCOVER_MAX = 500;
-var BATCH_DEFAULT = 100;
+var BATCH_DEFAULT = 500;
 var EXPECTED_MAX = 1e4;
 var KEY_MAX = 1024;
 var TITLE_MAX = 300;
@@ -468,7 +531,6 @@ var TYPE_BY_EXTENSION = {
   ".webp": "image/webp"
 };
 var METADATA_TYPE2 = "application/plune.metadata+json";
-var UPLOADS_AT_ONCE = 4;
 var NAME_MAX = 200;
 function nameOf(file) {
   const own = file.name.split(/[\\/]/).pop()?.trim() || (file.path === void 0 ? "" : basename2(file.path));
@@ -541,7 +603,7 @@ function tally(counts, noun) {
 }
 function boundKey(key) {
   if (key.value.length <= KEY_MAX) return key;
-  const digest = createHash("sha256").update(key.value).digest("hex").slice(0, 16);
+  const digest = createHash2("sha256").update(key.value).digest("hex").slice(0, 16);
   let head = key.value.slice(0, KEY_MAX - digest.length - 1);
   if (/[\uD800-\uDBFF]$/.test(head)) head = head.slice(0, -1);
   return { ...key, value: `${head}#${digest}` };
@@ -599,9 +661,18 @@ async function startRun(passed, declared) {
   const batchSize = Math.min(cfg.batchSize ?? BATCH_DEFAULT, BATCH_MAX);
   const offerDiscovered = cfg.offerDiscovered ?? false;
   const token = cfg.token ?? loadToken() ?? "";
+  const uploadsAtOnce = Math.min(Math.max(Math.floor(cfg.uploadConcurrency ?? UPLOAD_CONCURRENCY.default), UPLOAD_CONCURRENCY.min), UPLOAD_CONCURRENCY.max);
+  const uploadRetries = Math.min(Math.max(Math.floor(cfg.uploadRetries ?? UPLOAD_RETRIES.default), UPLOAD_RETRIES.min), UPLOAD_RETRIES.max);
+  let retried = 0;
+  let uploadMs = 0;
+  let requests = 0;
+  let existed = 0;
+  let batchMissing = false;
   const client = createClient({
     apiUrl: resolveApiUrl(cfg.apiUrl),
     token,
+    uploadRetries,
+    onRetry: () => void (retried += 1),
     ...cfg.fetchImpl !== void 0 ? { fetchImpl: cfg.fetchImpl } : {}
   });
   const stats = {
@@ -652,6 +723,7 @@ async function startRun(passed, declared) {
   if (offline) {
     log('plune: no API token \u2014 run "plune login" first. Results will be written to the fallback file.');
   }
+  for (const warning of env.warnings) log(`plune: ${warning}`);
   if (env.ignored.length > 0) {
     log(`plune: ignoring ${env.ignored.join(", ")} \u2014 a run has nowhere to store them yet.`);
   }
@@ -779,9 +851,10 @@ async function startRun(passed, declared) {
     else log(`plune: ${KINDS[kind].label} "${name}" not uploaded \u2014 ${SKIPPED[why]}.`);
   }
   function ask(job, size) {
+    requests += 1;
     return client.post(`/v1/results/${encodeURIComponent(job.id)}/files/uploads`, {
       files: [{ name: job.name, contentType: job.type, size }]
-    });
+    }, uploadRetries);
   }
   function failed(job, why) {
     countsOf(job.kind).failed += 1;
@@ -820,6 +893,7 @@ async function startRun(passed, declared) {
     }
     const refusal = kind === "text" ? textRefusal(bytes) : void 0;
     if (refusal !== void 0) return skip(kind, job.name, refusal);
+    requests += 1;
     const out = await client.upload(
       `/v1/results/${encodeURIComponent(job.id)}/files?name=${encodeURIComponent(job.name)}`,
       bytes,
@@ -842,11 +916,12 @@ async function startRun(passed, declared) {
       if (fresh === void 0) return failedToBucket(job, "bad_answer");
       link = fresh;
     }
-    const done2 = await client.post(`/v1/files/${encodeURIComponent(link.id)}/complete`, {});
+    requests += 1;
+    const done2 = await client.post(`/v1/files/${encodeURIComponent(link.id)}/complete`, {}, uploadRetries);
     if (!done2.ok) return failedToBucket(job, codeOf(done2));
     countsOf(job.kind).uploaded += 1;
   }
-  let free = UPLOADS_AT_ONCE;
+  let free = uploadsAtOnce;
   const waiting = [];
   async function gated(work) {
     if (free === 0) await new Promise((resolve2) => waiting.push(resolve2));
@@ -902,6 +977,245 @@ async function startRun(passed, declared) {
     }
     return () => uploadToBucket(job, size, link);
   }
+  async function uploadEach(jobs) {
+    const byResult = /* @__PURE__ */ new Map();
+    for (const job of jobs) byResult.set(job.id, [...byResult.get(job.id) ?? [], job]);
+    await Promise.all(
+      [...byResult.values()].map(async (group) => {
+        const work = [];
+        for (const job of group) {
+          const act = await plan(job);
+          if (act !== void 0) work.push(gated(act));
+        }
+        await Promise.all(work);
+      })
+    );
+  }
+  async function measure(job) {
+    let size;
+    if (job.body !== void 0) size = job.body.length;
+    else if (job.path === void 0) return void skip(job.kind, job.name, "missing");
+    else {
+      try {
+        size = (await disk.stat(job.path)).size;
+      } catch {
+        return void skip(job.kind, job.name, "missing");
+      }
+    }
+    if (size === 0) return void skip(job.kind, job.name, "empty");
+    return size;
+  }
+  const routeMissing = (out) => !out.ok && out.status === 404 && out.detail === "" && out.code === void 0;
+  function takeRoom(job) {
+    if (job.kind === "file") {
+      skip(job.kind, job.name, "noStorage");
+      return false;
+    }
+    const roomKey = `${job.id}/${job.kind}`;
+    const left = rooms.get(roomKey) ?? KINDS[job.kind].room;
+    if (left === 0) {
+      skip(job.kind, job.name, KINDS[job.kind].limit);
+      return false;
+    }
+    rooms.set(roomKey, left - 1);
+    return true;
+  }
+  function refusedItem(job, size, item) {
+    const code = item.code ?? "refused";
+    if (code === "duplicate") existed += 1;
+    else if (code === "no_storage") skip(job.kind, job.name, refusedHere(job, size) ?? "noStorage");
+    else if (code === "too_many_files") skip(job.kind, job.name, KINDS[job.kind].limit);
+    else if (BUCKET_CODES.has(code)) failedToBucket(job, code);
+    else failed(job, code);
+  }
+  const itemPause = (round) => new Promise((r) => setTimeout(r, Math.min(250 * 2 ** round, 4e3)));
+  async function batchOf(jobs) {
+    if (batchMissing) return uploadEach(jobs);
+    const sized = [];
+    for (const job of jobs) {
+      const size = await measure(job);
+      if (size === void 0) continue;
+      try {
+        sized.push({ job, size, sha256: job.body !== void 0 ? sha256Bytes(job.body) : await sha256File(job.path) });
+      } catch {
+        skip(job.kind, job.name, "missing");
+      }
+    }
+    if (sized.length === 0) return;
+    const announced = await gated(() => {
+      requests += 1;
+      return client.post(
+        "/v1/files/uploads-batch",
+        { items: sized.map((s) => ({ resultId: s.job.id, name: s.job.name, contentType: s.job.type, size: s.size, sha256: s.sha256 })) },
+        uploadRetries
+      );
+    });
+    if (routeMissing(announced)) {
+      batchMissing = true;
+      return uploadEach(sized.map((s) => s.job));
+    }
+    const verdicts = announced.ok ? announced.body?.items : void 0;
+    if (!announced.ok || !Array.isArray(verdicts) || verdicts.length !== sized.length) {
+      for (const s of sized) {
+        if (announced.ok) failed(s.job, "bad_answer");
+        else if (announced.code !== void 0) failedToBucket(s.job, announced.code);
+        else failed(s.job, announced.detail || announced.kind);
+      }
+      return;
+    }
+    const puts = [];
+    const directs = [];
+    sized.forEach((s, i) => {
+      const v = verdicts[i] ?? {};
+      if (v.status === "exists") existed += 1;
+      else if (v.status === "direct") {
+        if (takeRoom(s.job)) directs.push(s);
+      } else if (v.status === "upload") {
+        const link = linkOf(v);
+        if (link === void 0) return failed(s.job, "bad_answer");
+        if (!bucketSeen) {
+          bucketSeen = true;
+          log(BUCKET_FOUND);
+        }
+        puts.push({ s, link });
+      } else if (v.status === "refused") refusedItem(s.job, s.size, v);
+      else failed(s.job, "bad_answer");
+    });
+    const toComplete = [];
+    await Promise.all(
+      puts.map(
+        ({ s, link: first }) => gated(async () => {
+          const source = s.job.body !== void 0 ? { body: s.job.body } : { path: s.job.path, size: s.size };
+          let link = first;
+          for (let renewed = false; ; ) {
+            const put = await client.put(link.url, link.headers, source);
+            if (put.ok) break;
+            if (put.status !== 403 || renewed) return failedToBucket(s.job, put.code);
+            renewed = true;
+            requests += 1;
+            const again = await client.post(
+              "/v1/files/uploads-batch",
+              { items: [{ resultId: s.job.id, name: s.job.name, contentType: s.job.type, size: s.size, sha256: s.sha256 }] },
+              uploadRetries
+            );
+            const fresh = again.ok ? linkOf(again.body?.items?.[0]) : void 0;
+            if (fresh === void 0) return failedToBucket(s.job, again.ok ? "bad_answer" : codeOf(again));
+            link = fresh;
+          }
+          toComplete.push({ job: s.job, id: link.id });
+        })
+      )
+    );
+    await complete(toComplete);
+    await sendDirect(directs);
+  }
+  async function complete(items) {
+    for (let round = 0; items.length > 0; round += 1) {
+      const out = await gated(() => {
+        requests += 1;
+        return client.post("/v1/files/complete-batch", { ids: items.map((i) => i.id) }, uploadRetries);
+      });
+      if (routeMissing(out)) {
+        await Promise.all(
+          items.map(
+            (i) => gated(async () => {
+              requests += 1;
+              const one = await client.post(`/v1/files/${encodeURIComponent(i.id)}/complete`, {}, uploadRetries);
+              if (one.ok) countsOf(i.job.kind).uploaded += 1;
+              else failedToBucket(i.job, codeOf(one));
+            })
+          )
+        );
+        return;
+      }
+      const verdicts = out.ok ? out.body?.items : void 0;
+      if (!out.ok || !Array.isArray(verdicts) || verdicts.length !== items.length) {
+        for (const i of items) failedToBucket(i.job, out.ok ? "bad_answer" : codeOf(out));
+        return;
+      }
+      const again = [];
+      items.forEach((i, at) => {
+        const v = verdicts[at] ?? {};
+        if (v.status === "ready") countsOf(i.job.kind).uploaded += 1;
+        else if (v.retryable === true && round < Math.min(uploadRetries, 3)) again.push(i);
+        else refusedItem(i.job, 0, v.status === "refused" ? v : { code: "bad_answer" });
+      });
+      items = again;
+      if (items.length > 0) {
+        retried += items.length;
+        await itemPause(round);
+      }
+    }
+  }
+  async function sendDirect(items) {
+    const groups = [];
+    let bytes = 0;
+    for (const item of items) {
+      const group = groups[groups.length - 1];
+      if (group === void 0 || group.length >= FILES_BATCH_MAX || bytes + item.size > DIRECT_BATCH_BYTES) {
+        groups.push([item]);
+        bytes = item.size;
+      } else {
+        group.push(item);
+        bytes += item.size;
+      }
+    }
+    for (const group of groups) {
+      const body = [];
+      const sent = [];
+      for (const { job, size } of group) {
+        const { kind } = job;
+        if (size > KINDS[kind].bytes) {
+          skip(kind, job.name, KINDS[kind].size);
+          continue;
+        }
+        let data;
+        try {
+          data = job.body ?? await disk.readFile(job.path);
+        } catch {
+          skip(kind, job.name, "missing");
+          continue;
+        }
+        const refusal = kind === "text" ? textRefusal(data) : void 0;
+        if (refusal !== void 0) {
+          skip(kind, job.name, refusal);
+          continue;
+        }
+        body.push({ resultId: job.id, name: job.name, contentType: job.type, data: data.toString("base64") });
+        sent.push({ job, size });
+      }
+      if (body.length === 0) continue;
+      const out = await gated(() => {
+        requests += 1;
+        return client.post("/v1/files/direct-batch", { items: body }, uploadRetries);
+      });
+      if (routeMissing(out)) {
+        batchMissing = true;
+        for (const { job, size } of sent) await gated(() => uploadDirect(job, size));
+        continue;
+      }
+      const verdicts = out.ok ? out.body?.items : void 0;
+      if (!out.ok || !Array.isArray(verdicts) || verdicts.length !== sent.length) {
+        for (const { job } of sent) failed(job, out.ok ? "bad_answer" : out.detail || out.kind);
+        continue;
+      }
+      sent.forEach(({ job }, i) => {
+        const v = verdicts[i] ?? {};
+        if (v.status === "stored") countsOf(job.kind).uploaded += 1;
+        else if (v.status === "exists") existed += 1;
+        else refusedItem(job, 0, v.status === "refused" ? v : { code: "bad_answer" });
+      });
+    }
+  }
+  async function uploadBatched(jobs) {
+    const batches = chunk(jobs, FILES_BATCH_MAX);
+    let next = 0;
+    await Promise.all(
+      Array.from({ length: Math.min(BATCH_PIPELINES, batches.length) }, async () => {
+        for (let at = next++; at < batches.length; at = next++) await batchOf(batches[at]);
+      })
+    );
+  }
   async function upload(items, filesByKey) {
     if (filesByKey.size === 0 || !Array.isArray(items)) return;
     const jobs = [];
@@ -926,18 +1240,10 @@ async function startRun(passed, declared) {
         }
       }
     }
-    const byResult = /* @__PURE__ */ new Map();
-    for (const job of jobs) byResult.set(job.id, [...byResult.get(job.id) ?? [], job]);
-    await Promise.all(
-      [...byResult.values()].map(async (group) => {
-        const work = [];
-        for (const job of group) {
-          const act = await plan(job);
-          if (act !== void 0) work.push(gated(act));
-        }
-        await Promise.all(work);
-      })
-    );
+    const started = Date.now();
+    if (batchMissing) await uploadEach(jobs);
+    else await uploadBatched(jobs);
+    uploadMs += Date.now() - started;
   }
   async function flush() {
     if (buffer.length === 0) return;
@@ -1030,6 +1336,13 @@ async function startRun(passed, declared) {
     }
     if (stats.deferred > 0) parts.push(`${stats.deferred} not delivered \u2014 written to ${fallbackPath}`);
     if (shortened.size > 0) parts.push(`${shortened.size} test name(s) shortened to fit a key`);
+    const files = [stats.screenshots, stats.textFiles, stats.otherFiles];
+    const total = (what) => files.reduce((n, counts) => n + counts[what], 0);
+    if (total("uploaded") + total("skipped") + total("failed") + existed > 0) {
+      log(
+        `plune: files \u2014 ${total("uploaded")} uploaded, ${total("skipped")} skipped, ${existed} already there (skipped), ${retried} retried, ${total("failed")} dropped, in ${(uploadMs / 1e3).toFixed(1)} s (${uploadsAtOnce} at once, ${requests} request(s) to Plune)`
+      );
+    }
     log(`plune: ${parts.join(" \xB7 ")}`);
     if (stats.deferred > 0 && process.env["GITHUB_ACTIONS"] === "true") {
       log(`::warning::${stats.deferred} result(s) were not delivered to Plune \u2014 see the reporting step's log.`);
@@ -1086,9 +1399,9 @@ async function startRun(passed, declared) {
 }
 
 // src/util/hash.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function sha256(input) {
-  return createHash2("sha256").update(input, "utf8").digest("hex");
+  return createHash3("sha256").update(input, "utf8").digest("hex");
 }
 
 // src/reporter-core/result-key.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plune-ai/cli",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "AI-powered assertion testing for LLM apps — write assertions, run them against any provider, get a pass/fail report (local, CI, or diff).",
   "keywords": [
     "ai",