@plune-ai/cli 0.7.0 → 0.9.0

package/dist/cli.cjs

@@ -2267,19 +2267,35 @@ function count(env, name) {
   const n = Number(raw);
   return Number.isInteger(n) && n > 0 ? n : void 0;
 }
+function list(env, name) {
+  const raw = value(env, name);
+  if (raw === void 0) return void 0;
+  const items = raw.split(",").map((s) => s.trim()).filter((s) => s !== "");
+  return items.length === 0 ? void 0 : items;
+}
 function readEnv(env = process.env) {
   const externalKey = value(env, "PLUNE_RUN");
   const token = value(env, "PLUNE_TOKEN");
   const apiUrl = value(env, "PLUNE_API_URL");
   const fallbackPath = value(env, "PLUNE_FALLBACK");
   const batchSize = count(env, "PLUNE_BATCH_SIZE");
+  const title = value(env, "PLUNE_RUN_TITLE");
+  const environment = value(env, "PLUNE_ENV");
+  const labels = list(env, "PLUNE_LABELS");
+  const offerDiscovered = flag(env, "PLUNE_CREATE");
   return {
     config: {
       ...externalKey !== void 0 ? { externalKey } : {},
       ...token !== void 0 ? { token } : {},
       ...apiUrl !== void 0 ? { apiUrl } : {},
       ...fallbackPath !== void 0 ? { fallbackPath } : {},
-      ...batchSize !== void 0 ? { batchSize } : {}
+      ...batchSize !== void 0 ? { batchSize } : {},
+      ...title !== void 0 ? { title } : {},
+      ...environment !== void 0 ? { environment } : {},
+      ...labels !== void 0 ? { labels } : {},
+      // Only when set: `false` here would outrank a config file that asked for it, and an unset
+      // variable is not an instruction.
+      ...offerDiscovered ? { offerDiscovered } : {}
     },
     // Two names for two situations that end the same way. `SHARED_RUN` says other processes are
     // reporting into this run; `PROCEED` says the job will close it on its own schedule. Either
@@ -2293,12 +2309,7 @@ var init_env2 = __esm({
   "src/reporter-core/env.ts"() {
     "use strict";
     init_cjs_shims();
-    UNSUPPORTED_VARS = [
-      "PLUNE_RUN_TITLE",
-      "PLUNE_ENV",
-      "PLUNE_LABELS",
-      "PLUNE_GROUP"
-    ];
+    UNSUPPORTED_VARS = ["PLUNE_GROUP"];
   }
 });
 
@@ -2331,6 +2342,14 @@ function chunk(items, size) {
   for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
   return out;
 }
+function warnIfDropped(sent, run, log) {
+  const names = Object.keys(sent);
+  if (names.length === 0) return;
+  if (names.some((name) => run[name] != null)) return;
+  log(
+    `plune: this deployment stored none of ${names.join(", ")} \u2014 it is older than the fields. The run is otherwise reported in full.`
+  );
+}
 async function startRun(passed, expected) {
   const env = readEnv();
   const stated = Object.fromEntries(Object.entries(passed).filter(([, v]) => v !== void 0));
@@ -2340,6 +2359,7 @@ async function startRun(passed, expected) {
   const fallbackPath = cfg.fallbackPath ?? DEFAULT_FALLBACK_PATH;
   const externalKey = cfg.externalKey ?? null;
   const batchSize = Math.min(cfg.batchSize ?? BATCH_DEFAULT, BATCH_MAX);
+  const offerDiscovered = cfg.offerDiscovered ?? false;
   const token = cfg.token ?? loadToken() ?? "";
   const client = createClient({
     apiUrl: resolveApiUrl(cfg.apiUrl),
@@ -2352,10 +2372,12 @@ async function startRun(passed, expected) {
     conflict: 0,
     rejected: 0,
     unresolved: 0,
+    offered: 0,
     deferred: 0
   };
   const resolved = /* @__PURE__ */ new Map();
   let buffer = [];
+  const discoveries = /* @__PURE__ */ new Map();
   let runId = null;
   let joined = false;
   let offline = token === "";
@@ -2398,16 +2420,23 @@ async function startRun(passed, expected) {
     if (expected !== void 0 && expected.length > EXPECTED_MAX) {
       log(`plune: ${expected.length} tests is more than the run configuration holds \u2014 reporting the first ${EXPECTED_MAX}.`);
     }
+    const described = {
+      ...cfg.title !== void 0 ? { title: cfg.title } : {},
+      ...cfg.environment !== void 0 ? { environment: cfg.environment } : {},
+      ...cfg.labels !== void 0 ? { labels: cfg.labels } : {}
+    };
     const start = await client.post("/v1/runs", {
       schemaVersion: 2,
       kind: cfg.kind ?? "automated",
       ...externalKey !== null ? { externalKey } : {},
       ...cfg.meta !== void 0 ? { meta: cfg.meta } : {},
-      ...configuration !== void 0 ? { configuration } : {}
+      ...configuration !== void 0 ? { configuration } : {},
+      ...described
     });
     if (start.ok) {
       runId = start.body.run.id;
       joined = start.status === 200;
+      warnIfDropped(described, start.body.run, log);
     } else {
       log(`plune: could not start the run (${start.detail || start.kind}). Results will be written to ${fallbackPath}.`);
     }
@@ -2422,6 +2451,32 @@ async function startRun(passed, expected) {
     }
     return unanswered ? { kind: "unanswered" } : { kind: "unmatched" };
   }
+  function remember(result) {
+    if (!offerDiscovered) return;
+    if (result.title === void 0 || result.specRef === void 0) return;
+    if (result.keys.length === 0) return;
+    discoveries.set(result.keys[0].value, {
+      keys: result.keys,
+      title: result.title,
+      source: result.source,
+      specRef: result.specRef,
+      rawStatus: result.rawStatus
+    });
+  }
+  async function offer() {
+    if (discoveries.size === 0 || offline || runId === null) return;
+    for (const batch of chunk([...discoveries.values()], DISCOVER_MAX)) {
+      const out = await client.post("/v1/review-items/discovered", {
+        discovered: batch,
+        runId
+      });
+      if (!out.ok) {
+        log(`plune: could not offer ${batch.length} unknown tests for review (${out.detail || out.kind}).`);
+        return;
+      }
+      stats.offered += out.body.results.filter((r) => r.outcome === "queued").length;
+    }
+  }
   async function flush() {
     if (buffer.length === 0) return;
     const pending = buffer;
@@ -2440,6 +2495,7 @@ async function startRun(passed, expected) {
         submissions.push({ ...rest, testCaseId: match.testCaseId });
       } else if (match.kind === "unmatched") {
         stats.unresolved += 1;
+        remember(result);
       } else {
         unanswered.push(result);
       }
@@ -2473,6 +2529,7 @@ async function startRun(passed, expected) {
     if (stats.conflict > 0) parts.push(`${stats.conflict} conflicting`);
     if (stats.rejected > 0) parts.push(`${stats.rejected} rejected`);
     if (stats.unresolved > 0) parts.push(`${stats.unresolved} with no matching test case`);
+    if (stats.offered > 0) parts.push(`${stats.offered} offered for review`);
     if (stats.deferred > 0) parts.push(`${stats.deferred} written to ${fallbackPath}`);
     log(`plune: ${parts.join(" \xB7 ")}`);
   }
@@ -2495,6 +2552,7 @@ async function startRun(passed, expected) {
       if (done) return;
       done = true;
       await flush();
+      await offer();
       if (runId !== null && !offline) {
         const out = await client.post(`/v1/runs/${runId}/events`, {
           event: "finish",
@@ -2508,6 +2566,7 @@ async function startRun(passed, expected) {
       if (done) return;
       done = true;
       await flush();
+      await offer();
       if (runId !== null) {
         log(`plune: run ${runId} is still open \u2014 close it with "plune run finish ${runId}".`);
       }
@@ -2515,7 +2574,7 @@ async function startRun(passed, expected) {
     }
   };
 }
-var RESOLVE_CHUNK, BATCH_MAX, BATCH_DEFAULT, EXPECTED_MAX;
+var RESOLVE_CHUNK, BATCH_MAX, DISCOVER_MAX, BATCH_DEFAULT, EXPECTED_MAX;
 var init_session = __esm({
   "src/reporter-core/session.ts"() {
     "use strict";
@@ -2527,6 +2586,7 @@ var init_session = __esm({
     init_fallback();
     RESOLVE_CHUNK = 500;
     BATCH_MAX = 500;
+    DISCOVER_MAX = 500;
     BATCH_DEFAULT = 100;
     EXPECTED_MAX = 1e4;
   }
@@ -2689,6 +2749,502 @@ var init_run_lifecycle = __esm({
   }
 });
 
+// src/reporter-core/result-key.ts
+function resultKey(testId, retry) {
+  const plain = `${testId}#${retry}`;
+  return plain.length <= RESULT_KEY_MAX ? plain : `${sha256(testId).slice(0, HASH_CHARS)}#${retry}`;
+}
+var RESULT_KEY_MAX, HASH_CHARS;
+var init_result_key = __esm({
+  "src/reporter-core/result-key.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_hash();
+    RESULT_KEY_MAX = 200;
+    HASH_CHARS = 32;
+  }
+});
+
+// src/importers/xml.ts
+function decode(raw) {
+  if (!raw.includes("&")) return raw;
+  return raw.replace(/&(#[xX][0-9a-fA-F]+|#[0-9]+|[a-zA-Z][a-zA-Z0-9]*);/g, (whole, body) => {
+    if (body.startsWith("#")) {
+      const hex = body[1] === "x" || body[1] === "X";
+      const code = Number.parseInt(hex ? body.slice(2) : body.slice(1), hex ? 16 : 10);
+      try {
+        return Number.isNaN(code) ? whole : String.fromCodePoint(code);
+      } catch {
+        return whole;
+      }
+    }
+    return NAMED[body] ?? whole;
+  });
+}
+function parseXml(source, file) {
+  const root = { name: "#document", attrs: {}, children: [], text: "", line: 1 };
+  const stack = [root];
+  let i = 0;
+  let line = 1;
+  const advance = (to) => {
+    for (let j = i; j < to; j++) if (source[j] === "\n") line += 1;
+    i = to;
+  };
+  const top = () => stack[stack.length - 1];
+  while (i < source.length) {
+    const lt = source.indexOf("<", i);
+    if (lt === -1) break;
+    if (lt > i) {
+      const between = source.slice(i, lt);
+      if (between.trim() !== "") top().text += decode(between);
+      advance(lt);
+    }
+    if (source.startsWith("<!--", i)) {
+      const end = source.indexOf("-->", i + 4);
+      if (end === -1) throw new XmlParseError(file, line, "a comment is never closed");
+      advance(end + 3);
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", i)) {
+      const end = source.indexOf("]]>", i + 9);
+      if (end === -1) throw new XmlParseError(file, line, "a CDATA section is never closed");
+      top().text += source.slice(i + 9, end);
+      advance(end + 3);
+      continue;
+    }
+    if (source.startsWith("<?", i)) {
+      const end = source.indexOf("?>", i + 2);
+      if (end === -1) throw new XmlParseError(file, line, "a processing instruction is never closed");
+      advance(end + 2);
+      continue;
+    }
+    if (source.startsWith("<!", i)) {
+      const end = source.indexOf(">", i + 2);
+      if (end === -1) throw new XmlParseError(file, line, "a declaration is never closed");
+      advance(end + 1);
+      continue;
+    }
+    if (source.startsWith("</", i)) {
+      const end = source.indexOf(">", i + 2);
+      if (end === -1) throw new XmlParseError(file, line, "a closing tag is never closed");
+      const name2 = source.slice(i + 2, end).trim();
+      const open = top();
+      if (open === root) throw new XmlParseError(file, line, `</${name2}> closes nothing`);
+      if (open.name !== name2) {
+        throw new XmlParseError(file, line, `</${name2}> closes <${open.name}>, opened on line ${open.line}`);
+      }
+      stack.pop();
+      advance(end + 1);
+      continue;
+    }
+    const startLine = line;
+    let j = i + 1;
+    const nameStart = j;
+    while (j < source.length && !NAME_END.test(source[j])) j += 1;
+    const name = source.slice(nameStart, j);
+    if (name === "") throw new XmlParseError(file, startLine, "a tag with no name");
+    const el = { name, attrs: {}, children: [], text: "", line: startLine };
+    let selfClosing = false;
+    for (; ; ) {
+      while (j < source.length && SPACE.test(source[j])) j += 1;
+      if (j >= source.length) throw new XmlParseError(file, startLine, `<${name}> is never closed`);
+      if (source[j] === "/" && source[j + 1] === ">") {
+        selfClosing = true;
+        j += 2;
+        break;
+      }
+      if (source[j] === ">") {
+        j += 1;
+        break;
+      }
+      const attrStart = j;
+      while (j < source.length && !ATTR_NAME_END.test(source[j])) j += 1;
+      const attr = source.slice(attrStart, j);
+      if (attr === "") throw new XmlParseError(file, startLine, `<${name}> has an attribute with no name`);
+      while (j < source.length && SPACE.test(source[j])) j += 1;
+      if (source[j] !== "=") {
+        throw new XmlParseError(file, startLine, `<${name}> attribute "${attr}" has no value`);
+      }
+      j += 1;
+      while (j < source.length && SPACE.test(source[j])) j += 1;
+      const quote = source[j];
+      if (quote !== '"' && quote !== "'") {
+        throw new XmlParseError(file, startLine, `<${name}> attribute "${attr}" is not quoted`);
+      }
+      const close = source.indexOf(quote, j + 1);
+      if (close === -1) throw new XmlParseError(file, startLine, `<${name}> attribute "${attr}" is never closed`);
+      el.attrs[attr] = decode(source.slice(j + 1, close));
+      j = close + 1;
+    }
+    top().children.push(el);
+    if (!selfClosing) stack.push(el);
+    advance(j);
+  }
+  if (stack.length > 1) {
+    const open = top();
+    throw new XmlParseError(file, open.line, `<${open.name}> is never closed`);
+  }
+  if (root.children.length === 0) throw new XmlParseError(file, 1, "no elements \u2014 is this an XML report?");
+  return root;
+}
+var XmlParseError, NAMED, NAME_END, ATTR_NAME_END, SPACE;
+var init_xml = __esm({
+  "src/importers/xml.ts"() {
+    "use strict";
+    init_cjs_shims();
+    XmlParseError = class extends Error {
+      constructor(file, line, detail) {
+        super(`${file}:${line} \u2014 ${detail}`);
+        this.file = file;
+        this.line = line;
+        this.name = "XmlParseError";
+      }
+      file;
+      line;
+    };
+    NAMED = {
+      amp: "&",
+      lt: "<",
+      gt: ">",
+      quot: '"',
+      apos: "'"
+    };
+    NAME_END = /[\s/>]/;
+    ATTR_NAME_END = /[\s=/>]/;
+    SPACE = /\s/;
+  }
+});
+
+// src/importers/junit.ts
+function locate(el, suite, out) {
+  for (const child of el.children) {
+    if (child.name === "testcase") out.push({ test: child, suite });
+    else locate(child, child.name === "testsuite" ? child : suite, out);
+  }
+}
+function outcomeOf(test) {
+  for (const name of ["error", "failure", "skipped"]) {
+    const found = test.children.find((c) => c.name === name);
+    if (found !== void 0) return { status: name, detail: found };
+  }
+  return { status: "pass", detail: void 0 };
+}
+function errorTextOf(detail) {
+  if (detail === void 0) return "";
+  const head = [detail.attrs["message"], detail.attrs["type"]].filter((s) => s !== void 0 && s !== "");
+  return [...head, detail.text.trim()].filter((s) => s !== "").join("\n\n");
+}
+function keyOf(classname, name) {
+  return { kind: "path-title", value: classname === "" ? name : `${classname}#${name}` };
+}
+function titleOf(classname, name) {
+  if (classname === "") return name;
+  if (classname === name || classname.endsWith(` ${name}`) || classname.endsWith(`\u203A${name}`)) return classname;
+  return `${classname} \u203A ${name}`;
+}
+function specRefOf(test, suite, classname) {
+  const file = test.attrs["file"] ?? suite?.attrs["file"] ?? "";
+  if (file !== "") {
+    const line = test.attrs["line"];
+    return line !== void 0 && line !== "" ? `${file}:${line}` : file;
+  }
+  return classname === "" ? void 0 : classname;
+}
+function executionOf(test, suite) {
+  const stamp = suite?.attrs["timestamp"];
+  if (stamp === void 0 || stamp === "") return void 0;
+  const started = new Date(stamp);
+  if (Number.isNaN(started.getTime())) return void 0;
+  const seconds = Number.parseFloat(test.attrs["time"] ?? "");
+  const durationMs = Number.isFinite(seconds) && seconds >= 0 ? Math.round(seconds * 1e3) : 0;
+  return {
+    startedAt: started.toISOString(),
+    finishedAt: new Date(started.getTime() + durationMs).toISOString(),
+    durationMs,
+    // The base format has no reruns. Surefire's `<rerunFailure>` does, and reading it is work for
+    // the day somebody asks; reporting 0 says «first attempt», which is true of every case here.
+    retry: 0
+  };
+}
+function readJUnit(source, file) {
+  const doc = parseXml(source, file);
+  const found = [];
+  locate(doc, void 0, found);
+  return found.map(({ test, suite }) => {
+    const name = test.attrs["name"] ?? "";
+    const classname = test.attrs["classname"] ?? test.attrs["class"] ?? "";
+    const { status, detail } = outcomeOf(test);
+    const key = keyOf(classname, name);
+    const specRef = specRefOf(test, suite, classname);
+    const errorContext = errorTextOf(detail);
+    const execution = executionOf(test, suite);
+    return {
+      resultKey: resultKey(key.value, 0),
+      keys: [key],
+      source: SOURCE,
+      rawStatus: status,
+      title: titleOf(classname, name),
+      ...specRef !== void 0 ? { specRef } : {},
+      ...execution !== void 0 ? { execution } : {},
+      ...errorContext !== "" ? { errorContext } : {}
+    };
+  });
+}
+function looksLikeJUnit(source) {
+  return /<\s*testsuites?\b/.test(source.slice(0, 4096));
+}
+var SOURCE;
+var init_junit = __esm({
+  "src/importers/junit.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_result_key();
+    init_xml();
+    SOURCE = "junit";
+  }
+});
+
+// src/importers/playwright-json.ts
+function statedIdOf(test, title) {
+  const annotation = test.annotations?.find((a) => a.type === "PluneId")?.description;
+  if (annotation !== void 0 && annotation !== "") return annotation;
+  return TOKEN.exec(title)?.[1];
+}
+function errorTextOf2(result) {
+  return (result.errors ?? []).map((e) => e.stack ?? e.message ?? e.value ?? "").filter((text2) => text2 !== "").join("\n\n");
+}
+function pendingFrom(spec, test, result, file, titles) {
+  const pathTitle = [file, ...titles].join("#");
+  const seed = test.id ?? pathTitle;
+  const stated = statedIdOf(test, spec.title ?? "");
+  const expected = test.expectedStatus;
+  const errorContext = errorTextOf2(result);
+  const keys = [
+    ...test.id !== void 0 ? [{ kind: "playwright-id", value: test.id }] : [],
+    { kind: "path-title", value: pathTitle }
+  ];
+  const started = result.startTime !== void 0 ? new Date(result.startTime) : void 0;
+  const durationMs = typeof result.duration === "number" && result.duration >= 0 ? result.duration : 0;
+  const retry = typeof result.retry === "number" && result.retry >= 0 ? result.retry : 0;
+  return {
+    resultKey: resultKey(seed, retry),
+    ...stated !== void 0 ? { testCaseId: stated } : {},
+    keys,
+    title: titles.join(" \u203A "),
+    specRef: spec.line !== void 0 ? `${file}:${spec.line}` : file,
+    source: SOURCE2,
+    // Untouched, as everywhere: `timedOut` means what the project's map says it means, not what
+    // this file decided.
+    rawStatus: result.status ?? "unknown",
+    ...expected === "failed" || expected === "skipped" ? { expectedStatus: expected } : {},
+    ...started !== void 0 && !Number.isNaN(started.getTime()) ? {
+      execution: {
+        startedAt: started.toISOString(),
+        finishedAt: new Date(started.getTime() + durationMs).toISOString(),
+        durationMs,
+        retry,
+        ...result.workerIndex !== void 0 ? { worker: String(result.workerIndex) } : {}
+      }
+    } : {},
+    ...errorContext !== "" ? { errorContext } : {}
+  };
+}
+function walk(suite, describes, depth, out) {
+  const here = depth === 0 ? [] : [...describes, suite.title ?? ""];
+  for (const spec of suite.specs ?? []) {
+    const file = spec.file ?? suite.file ?? suite.title ?? "";
+    const titles = [...here, spec.title ?? ""];
+    for (const test of spec.tests ?? []) {
+      for (const result of test.results ?? []) out.push(pendingFrom(spec, test, result, file, titles));
+    }
+  }
+  for (const child of suite.suites ?? []) walk(child, here, depth + 1, out);
+}
+function readPlaywrightJson(source, file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (err) {
+    throw new JsonReportError(file, `not JSON \u2014 ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.suites)) {
+    throw new JsonReportError(file, 'no "suites" array \u2014 is this a Playwright JSON report?');
+  }
+  const out = [];
+  for (const suite of parsed.suites) walk(suite, [], 0, out);
+  return out;
+}
+function looksLikePlaywrightJson(source) {
+  const head = source.slice(0, 4096);
+  return head.trimStart().startsWith("{") && head.includes('"suites"');
+}
+var SOURCE2, TOKEN, JsonReportError;
+var init_playwright_json = __esm({
+  "src/importers/playwright-json.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_result_key();
+    SOURCE2 = "playwright";
+    TOKEN = /@P([A-Za-z0-9_-]+)/;
+    JsonReportError = class extends Error {
+      constructor(file, detail) {
+        super(`${file} \u2014 ${detail}`);
+        this.file = file;
+        this.name = "JsonReportError";
+      }
+      file;
+    };
+  }
+});
+
+// src/importers/index.ts
+var importers_exports = {};
+__export(importers_exports, {
+  IMPORT_FORMATS: () => IMPORT_FORMATS,
+  JsonReportError: () => JsonReportError,
+  UnknownFormatError: () => UnknownFormatError,
+  XmlParseError: () => XmlParseError,
+  detectFormat: () => detectFormat,
+  readReport: () => readReport
+});
+function detectFormat(source, file) {
+  if (looksLikeJUnit(source)) return "junit";
+  if (looksLikePlaywrightJson(source)) return "playwright-json";
+  throw new UnknownFormatError(
+    file,
+    'no <testsuite> and no Playwright "suites" \u2014 this is not a report we can read.'
+  );
+}
+function readReport(source, file, format) {
+  const chosen = format ?? detectFormat(source, file);
+  return {
+    format: chosen,
+    results: chosen === "junit" ? readJUnit(source, file) : readPlaywrightJson(source, file)
+  };
+}
+var IMPORT_FORMATS, UnknownFormatError;
+var init_importers = __esm({
+  "src/importers/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_junit();
+    init_playwright_json();
+    init_xml();
+    init_playwright_json();
+    IMPORT_FORMATS = ["junit", "playwright-json"];
+    UnknownFormatError = class extends Error {
+      constructor(file, detail) {
+        super(`${file} \u2014 ${detail} Say which with --format ${IMPORT_FORMATS.join(" | ")}.`);
+        this.name = "UnknownFormatError";
+      }
+    };
+  }
+});
+
+// src/cli/commands/run-import.ts
+var run_import_exports = {};
+__export(run_import_exports, {
+  handleRunImport: () => handleRunImport
+});
+async function handleRunImport(options) {
+  const write = options.write ?? ((line) => void process.stdout.write(`${line}
+`));
+  let source;
+  try {
+    source = fs8.readFileSync(options.file, "utf8");
+  } catch {
+    throw new RunCommandError(`Cannot read ${options.file}.`);
+  }
+  const { format, results } = readReport(source, options.file, options.format);
+  if (results.length === 0) {
+    throw new RunCommandError(`No test cases in ${options.file} \u2014 it parsed, but there is nothing in it.`);
+  }
+  const env = readEnv();
+  const apiUrl = resolveApiUrl(options.apiUrl ?? env.config.apiUrl);
+  const token = options.token ?? env.config.token ?? loadToken() ?? "";
+  if (token === "") throw new NoTokenError();
+  const session = await startRun(
+    {
+      apiUrl,
+      token,
+      ...options.fetchImpl !== void 0 ? { fetchImpl: options.fetchImpl } : {},
+      ...options.key !== void 0 ? { externalKey: options.key } : {},
+      ...options.create === true ? { offerDiscovered: true } : {},
+      kind: "automated",
+      meta: { runner: format },
+      log: write
+    },
+    // The file is the complete list of what ran, so the platform can resolve every test in one
+    // request and derive what never ran from the same list (AC-09/AC-10) — the lazy path would be
+    // a lookup per result.
+    results.map((r) => r.keys)
+  );
+  for (const result2 of results) await session.add(result2);
+  await session.finish();
+  const stats = session.stats;
+  const result = {
+    runId: session.runId,
+    format,
+    parsed: results.length,
+    accepted: stats.accepted,
+    duplicate: stats.duplicate,
+    conflict: stats.conflict,
+    rejected: stats.rejected,
+    unresolved: stats.unresolved,
+    offered: stats.offered,
+    deferred: stats.deferred,
+    unlocatable: results.filter((r) => r.specRef === void 0).length,
+    offering: options.create === true
+  };
+  for (const line of describe(result, apiUrl)) write(line);
+  return result;
+}
+function runUrl2(apiUrl, id) {
+  const web = dashboardUrl(apiUrl);
+  return web === void 0 ? `${apiUrl}/v1/runs/${id}` : `${web}/runs/${id}`;
+}
+function describe(result, apiUrl) {
+  const lines = [
+    `Imported ${result.parsed} result(s) from a ${result.format} report: ${result.accepted} accepted, ${result.duplicate} already there, ${result.unresolved} unmatched.`
+  ];
+  if (result.conflict > 0 || result.rejected > 0) {
+    lines.push(`${result.conflict} conflicted and ${result.rejected} were refused.`);
+  }
+  if (result.deferred > 0) {
+    lines.push(
+      `${result.deferred} could not be sent and are in the fallback file \u2014 "plune run report" retries them.`
+    );
+  }
+  if (result.offered > 0) {
+    lines.push(`${result.offered} unknown test(s) offered to the review queue.`);
+  } else if (result.unresolved > 0 && !result.offering) {
+    lines.push("Nothing was offered to the review queue \u2014 pass --create to propose the unmatched tests.");
+  } else if (result.unresolved > 0) {
+    lines.push("Nothing new to offer \u2014 the unmatched tests are already in the review queue.");
+  }
+  if (result.unlocatable > 0) {
+    lines.push(
+      `${result.unlocatable} test(s) carry no file or class in the report, so they cannot be offered for review \u2014 a reviewer would have nowhere to look.`
+    );
+  }
+  if (result.runId !== null) lines.push(runUrl2(apiUrl, result.runId));
+  return lines;
+}
+var fs8;
+var init_run_import = __esm({
+  "src/cli/commands/run-import.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs8 = __toESM(require("fs"), 1);
+    init_session();
+    init_importers();
+    init_run_lifecycle();
+    init_api_url();
+    init_credentials();
+    init_env2();
+  }
+});
+
 // src/cli/commands/report.ts
 var report_exports = {};
 __export(report_exports, {
@@ -2705,7 +3261,7 @@ function handleReport(opts = {}) {
   const file = path7.join(cwd, ".plune", "last-run.json");
   let raw;
   try {
-    raw = fs8.readFileSync(file, "utf8");
+    raw = fs9.readFileSync(file, "utf8");
   } catch {
     throw new ReportNotFoundError('No saved run found. Run "plune run" first.');
   }
@@ -2720,12 +3276,12 @@ function handleReport(opts = {}) {
   }
   return parsed;
 }
-var fs8, path7, ReportNotFoundError;
+var fs9, path7, ReportNotFoundError;
 var init_report = __esm({
   "src/cli/commands/report.ts"() {
     "use strict";
     init_cjs_shims();
-    fs8 = __toESM(require("fs"), 1);
+    fs9 = __toESM(require("fs"), 1);
     path7 = __toESM(require("path"), 1);
     ReportNotFoundError = class extends Error {
       code = "NO_SAVED_RUN";
@@ -2800,7 +3356,7 @@ function isRunResult2(v) {
 function loadRunResult(file, label) {
   let raw;
   try {
-    raw = fs9.readFileSync(file, "utf8");
+    raw = fs10.readFileSync(file, "utf8");
   } catch {
     throw new DiffInputError(`Cannot read ${label} run file: ${file}`);
   }
@@ -2820,12 +3376,12 @@ function handleDiff(opts) {
   const current = loadRunResult(opts.currentPath, "current");
   return diffRuns(baseline, current);
 }
-var fs9, DiffInputError;
+var fs10, DiffInputError;
 var init_diff2 = __esm({
   "src/cli/commands/diff.ts"() {
     "use strict";
     init_cjs_shims();
-    fs9 = __toESM(require("fs"), 1);
+    fs10 = __toESM(require("fs"), 1);
     init_diff();
     DiffInputError = class extends Error {
       code = "DIFF_INPUT";
@@ -2951,7 +3507,7 @@ async function runInitWizard(cwd) {
     return;
   }
   const outputPath = path8.join(cwd, "plune.yaml");
-  if (fs10.existsSync(outputPath)) {
+  if (fs11.existsSync(outputPath)) {
     const overwrite = await clack.confirm({
       message: "plune.yaml already exists. Overwrite?"
     });
@@ -2990,17 +3546,17 @@ async function runInitWizard(cwd) {
 `;
   const spin = clack.spinner();
   spin.start("Writing plune.yaml\u2026");
-  fs10.writeFileSync(outputPath, header + "\n" + (0, import_yaml2.stringify)(config), "utf8");
+  fs11.writeFileSync(outputPath, header + "\n" + (0, import_yaml2.stringify)(config), "utf8");
   spin.stop("plune.yaml created!");
   clack.outro("plune.yaml is ready.");
 }
-var clack, fs10, path8, import_yaml2;
+var clack, fs11, path8, import_yaml2;
 var init_wizard = __esm({
   "src/config/init/wizard.ts"() {
     "use strict";
     init_cjs_shims();
     clack = __toESM(require("@clack/prompts"), 1);
-    fs10 = __toESM(require("fs"), 1);
+    fs11 = __toESM(require("fs"), 1);
     path8 = __toESM(require("path"), 1);
     import_yaml2 = require("yaml");
     init_errors();
@@ -3010,19 +3566,19 @@ var init_wizard = __esm({
 // src/cli/templates/index.ts
 function writeTemplateFile(cwd, rel, content, force) {
   const target = path9.join(cwd, rel);
-  if (!force && fs11.existsSync(target)) {
+  if (!force && fs12.existsSync(target)) {
     return "skipped";
   }
-  fs11.mkdirSync(path9.dirname(target), { recursive: true });
-  fs11.writeFileSync(target, content, "utf8");
+  fs12.mkdirSync(path9.dirname(target), { recursive: true });
+  fs12.writeFileSync(target, content, "utf8");
   return "written";
 }
-var fs11, path9, ENV_EXAMPLE_TPL, EXAMPLE_JSONL_TPL, PLUNE_YAML_TPL;
+var fs12, path9, ENV_EXAMPLE_TPL, EXAMPLE_JSONL_TPL, PLUNE_YAML_TPL;
 var init_templates = __esm({
   "src/cli/templates/index.ts"() {
     "use strict";
     init_cjs_shims();
-    fs11 = __toESM(require("fs"), 1);
+    fs12 = __toESM(require("fs"), 1);
     path9 = __toESM(require("path"), 1);
     ENV_EXAMPLE_TPL = `# Copy this file to .env and replace the placeholders with your real keys.
 # .env is gitignored; .env.example is safe to commit.
@@ -3282,7 +3838,7 @@ function readRun(cwd, file) {
   const target = file !== void 0 ? path10.resolve(cwd, file) : path10.join(cwd, ".plune", "last-run.json");
   let raw;
   try {
-    raw = fs12.readFileSync(target, "utf8");
+    raw = fs13.readFileSync(target, "utf8");
   } catch {
     throw new SyncFileError(
       file !== void 0 ? `Run file not found: ${target}` : 'No run to sync. Run "plune run" first (or pass --file <path>).'
@@ -3346,12 +3902,12 @@ function reportSyncFailure(err, write) {
   }
   return null;
 }
-var fs12, path10, NotLoggedInError, TokenRejectedError2, SyncFileError, SyncNetworkError, SyncHttpError;
+var fs13, path10, NotLoggedInError, TokenRejectedError2, SyncFileError, SyncNetworkError, SyncHttpError;
 var init_sync = __esm({
   "src/cli/commands/sync.ts"() {
     "use strict";
     init_cjs_shims();
-    fs12 = __toESM(require("fs"), 1);
+    fs13 = __toESM(require("fs"), 1);
     path10 = __toESM(require("path"), 1);
     init_run_result_schema();
     init_api_url();
@@ -3397,14 +3953,14 @@ var init_sync = __esm({
 
 // src/cli/commands/cairn-artifact.ts
 async function findLatestCairnRun(runsDir = "runs") {
-  const entries = await fs13.readdir(runsDir, { withFileTypes: true }).catch(() => null);
+  const entries = await fs14.readdir(runsDir, { withFileTypes: true }).catch(() => null);
   if (entries === null) throw new NoCairnRunsError(runsDir);
   let newest;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const dir = path11.join(runsDir, entry.name);
     try {
-      const report = await fs13.lstat(path11.join(dir, "report.json"));
+      const report = await fs14.lstat(path11.join(dir, "report.json"));
       if (!report.isFile()) continue;
       if (newest === void 0 || report.mtimeMs > newest.at) {
         newest = { dir, at: report.mtimeMs };
@@ -3417,7 +3973,7 @@ async function findLatestCairnRun(runsDir = "runs") {
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await fs13.readFile(file, "utf8"));
+    return JSON.parse(await fs14.readFile(file, "utf8"));
   } catch {
     return void 0;
   }
@@ -3431,8 +3987,8 @@ async function defaultReadEvidence(dir) {
   });
 }
 function casesFromDesign(report) {
-  const list = Array.isArray(report["testCases"]) ? report["testCases"] : [];
-  return list.map((raw) => {
+  const list2 = Array.isArray(report["testCases"]) ? report["testCases"] : [];
+  return list2.map((raw) => {
     const c = asRecord(raw);
     const steps = (Array.isArray(c["steps"]) ? c["steps"] : []).map((s) => str(s)).filter((s) => s !== "");
     return {
@@ -3447,8 +4003,8 @@ function casesFromDesign(report) {
   });
 }
 function casesFromApi(report, verdicts) {
-  const list = Array.isArray(report["cases"]) ? report["cases"] : [];
-  return list.map((raw) => {
+  const list2 = Array.isArray(report["cases"]) ? report["cases"] : [];
+  return list2.map((raw) => {
     const c = asRecord(raw);
     const name = str(c["name"], "unnamed operation");
     const request = `${str(c["method"], "GET")} ${str(c["path"], "/")}`;
@@ -3502,12 +4058,12 @@ async function readCairnRun(dir, deps = {}) {
     cases
   };
 }
-var fs13, path11, SUPPORTED_ARTIFACT_VERSION, INGEST_SCHEMA_VERSION, NoCairnRunsError, CairnRunNotFoundError, CairnRunVersionError, CairnRunPartialError, CairnEvidenceAmbiguousError, asRecord, str;
+var fs14, path11, SUPPORTED_ARTIFACT_VERSION, INGEST_SCHEMA_VERSION, NoCairnRunsError, CairnRunNotFoundError, CairnRunVersionError, CairnRunPartialError, CairnEvidenceAmbiguousError, asRecord, str;
 var init_cairn_artifact = __esm({
   "src/cli/commands/cairn-artifact.ts"() {
     "use strict";
     init_cjs_shims();
-    fs13 = __toESM(require("fs/promises"), 1);
+    fs14 = __toESM(require("fs/promises"), 1);
     path11 = __toESM(require("path"), 1);
     SUPPORTED_ARTIFACT_VERSION = 1;
     INGEST_SCHEMA_VERSION = 1;
@@ -3854,6 +4410,36 @@ function createProgram() {
       await failRunCommand(err, verboseOf(command));
     }
   });
+  runCommand.command("import").argument("<file>", "A JUnit XML or Playwright JSON report").description("Turn a report another runner wrote into a run in Plune \u2014 no provider key needed").option("--format <fmt>", "junit | playwright-json; detected from the file when omitted").option("--key <externalKey>", "The key several jobs share so their reports land in one run").option("--create", "Offer tests nothing matched to the review queue", false).action(
+    async (file, options, command) => {
+      const [{ handleRunImport: handleRunImport2 }, { IMPORT_FORMATS: IMPORT_FORMATS2, UnknownFormatError: UnknownFormatError2, XmlParseError: XmlParseError2, JsonReportError: JsonReportError2 }] = await Promise.all([
+        Promise.resolve().then(() => (init_run_import(), run_import_exports)),
+        Promise.resolve().then(() => (init_importers(), importers_exports))
+      ]);
+      const format = options.format;
+      if (format !== void 0 && !IMPORT_FORMATS2.includes(format)) {
+        process.stderr.write(`Unknown --format "${format}". Use ${IMPORT_FORMATS2.join(" or ")}.
+`);
+        process.exit(2);
+        return;
+      }
+      try {
+        await handleRunImport2({
+          file,
+          ...format !== void 0 ? { format } : {},
+          ...options.key !== void 0 ? { key: options.key } : {},
+          ...options.create ? { create: true } : {}
+        });
+      } catch (err) {
+        if (err instanceof UnknownFormatError2 || err instanceof XmlParseError2 || err instanceof JsonReportError2) {
+          process.stderr.write(err.message + "\n");
+          process.exit(2);
+          return;
+        }
+        await failRunCommand(err, verboseOf(command));
+      }
+    }
+  );
   program.command("report").description("Render the most recent run in a chosen format").option("--format <fmt>", "console | json | markdown", "console").option("-o, --output <path>", "Write the report to a file instead of stdout").action(async (options, command) => {
     const globals = command.optsWithGlobals();
     const [{ loadEnv: loadEnv2 }, { handleReport: handleReport2, ReportNotFoundError: ReportNotFoundError2 }, { renderReport: renderReport2 }] = await Promise.all([