@piwitests/reporter 0.36.0 → 0.39.0

package/dist/cli/index.js

@@ -422,6 +422,7 @@ function formatGateResult(result) {
     );
   }
   for (const violation of result.violations) lines.push(`  \u2716 ${violation.message}`);
+  for (const warning of result.warnings ?? []) lines.push(`  \u26A0 ${warning}`);
   lines.push(`  ${facts.runUrl}`);
   return lines.join("\n");
 }
@@ -456,6 +457,9 @@ Policy (at least one is required):
   --fail-on-flaky          Fail when this run contains any flaky test
   --require-selection <key>  Fail when a test the named selection matches did not run or failed
 
+Warn-only (reported, never fails the build):
+  --max-uncovered-changes <n>  Warn when more than n changed files have no observed test reach
+
 Other:
   --json                   Print the raw result as JSON instead of a summary
   -h, --help               Show this help
@@ -477,9 +481,9 @@ function readCount(argv, name) {
   if (!Number.isFinite(n) || n < 0) throw new Error(`${name} expects a non-negative number, got "${raw}"`);
   return Math.floor(n);
 }
-function readRunIdFromFile(path11) {
+function readRunIdFromFile(path13) {
   try {
-    const parsed = JSON.parse(fs3.readFileSync(path11, "utf-8"));
+    const parsed = JSON.parse(fs3.readFileSync(path13, "utf-8"));
     const runId = Number(parsed.runId);
     return Number.isFinite(runId) && runId > 0 ? runId : null;
   } catch {
@@ -510,7 +514,13 @@ function parseGateArgs(argv, env) {
     failOnFlaky: argv.includes("--fail-on-flaky"),
     requireSelection: readOption2(argv, "--require-selection")
   };
-  return { serverUrl, apiKey: readOption2(argv, "--api-key") ?? env.PIWI_API_KEY ?? null, runId, policy };
+  return {
+    serverUrl,
+    apiKey: readOption2(argv, "--api-key") ?? env.PIWI_API_KEY ?? null,
+    runId,
+    policy,
+    maxUncoveredChanges: readCount(argv, "--max-uncovered-changes")
+  };
 }
 async function requestGate(args) {
   const headers = { "Content-Type": "application/json" };
@@ -518,7 +528,7 @@ async function requestGate(args) {
   const res = await fetch(`${args.serverUrl}/api/test-runs/${args.runId}/gate`, {
     method: "POST",
     headers,
-    body: JSON.stringify(args.policy)
+    body: JSON.stringify({ ...args.policy, maxUncoveredChanges: args.maxUncoveredChanges })
   });
   if (!res.ok) {
     const body = await res.json().catch(() => ({}));
@@ -778,7 +788,8 @@ var WORKFLOW_SKILLS = [
   "investigate-failure",
   "apply-locator-healing",
   "stabilize-flaky-tests",
-  "run-the-right-tests"
+  "run-the-right-tests",
+  "write-the-missing-test"
 ];
 var ALL_SKILLS = [SETUP_SKILL, ...WORKFLOW_SKILLS];
 var DEFAULT_SKILLS_DIR = path7.join(".claude", "skills");
@@ -1675,8 +1686,403 @@ async function runRun(argv, env = process.env) {
   return spawnPlaywrightForRun(args.pkgRunner, [...resolution.materialization.args, ...args.extra], runEnv);
 }
 
-// src/cli/index.ts
+// src/cli/probe.ts
+var import_node_child_process4 = require("child_process");
+var import_node_module3 = require("module");
+var fs10 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path12 = __toESM(require("path"));
+
+// src/internal/config/desktop.ts
+var fs9 = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path11 = __toESM(require("path"));
+
+// src/internal/config/env.ts
+var DEFAULTS = {
+  projectName: "default-project",
+  uploadTraces: true,
+  uploadReport: true,
+  liveFileUploads: true,
+  collectScmInfo: true,
+  collectCiInfo: true,
+  collectPerformanceMetrics: true,
+  captureLocators: true,
+  capturePageState: true,
+  // Off by default: the page inventory reads control and link names from every
+  // visited page, so it stays opt-in until a project turns it on.
+  capturePageInventory: false,
+  captureServerTraces: true,
+  sampleAriaOnPass: true,
+  uploadManifest: true,
+  defaultCapture: true,
+  streaming: true,
+  streamingBatchSize: 5,
+  streamingBatchDelay: 2e3,
+  maxStreamBufferBytes: 100 * 1024 * 1024,
+  failOnFlakyTests: false,
+  username: null,
+  password: null,
+  apiKey: null,
+  verbose: false
+};
+var PIWI_ENV_KEYS = {
+  serverUrl: "PIWI_DASHBOARD_URL",
+  projectName: "PIWI_PROJECT_NAME",
+  verbose: "PIWI_VERBOSE",
+  apiKey: "PIWI_API_KEY",
+  username: "PIWI_USERNAME",
+  password: "PIWI_PASSWORD",
+  environment: "PIWI_ENVIRONMENT",
+  label: "PIWI_LABEL",
+  runLabel: "PIWI_RUN_LABEL",
+  keep: "PIWI_KEEP",
+  streaming: "PIWI_STREAMING",
+  streamingBatchSize: "PIWI_STREAMING_BATCH_SIZE",
+  streamingBatchDelay: "PIWI_STREAMING_BATCH_DELAY",
+  maxStreamBufferBytes: "PIWI_MAX_STREAM_BUFFER_BYTES",
+  liveFileUploads: "PIWI_LIVE_FILE_UPLOADS",
+  failOnFlakyTests: "PIWI_FAIL_ON_FLAKY_TESTS",
+  uploadTraces: "PIWI_UPLOAD_TRACES",
+  uploadReport: "PIWI_UPLOAD_REPORT",
+  captureLocators: "PIWI_CAPTURE_LOCATORS",
+  capturePageState: "PIWI_CAPTURE_PAGE_STATE",
+  capturePageInventory: "PIWI_CAPTURE_PAGE_INVENTORY",
+  captureServerTraces: "PIWI_CAPTURE_SERVER_TRACES",
+  sampleAriaOnPass: "PIWI_SAMPLE_ARIA_ON_PASS",
+  uploadManifest: "PIWI_UPLOAD_MANIFEST",
+  defaultCapture: "PIWI_DEFAULT_CAPTURE",
+  inspectOnFailure: "PIWI_INSPECT_ON_FAIL",
+  pickLocatorOnFailure: "PIWI_PICK_LOCATOR_ON_FAIL",
+  outputFile: "PIWI_OUTPUT_FILE",
+  aiMode: "PIWI_AI",
+  aiDir: "PIWI_AI_DIR",
+  aiOnMiss: "PIWI_AI_ON_MISS",
+  aiMaxSteps: "PIWI_AI_MAX_FLOW_STEPS",
+  aiMaxSnapshotChars: "PIWI_AI_MAX_SNAPSHOT_CHARS",
+  aiOptionalProbeTimeout: "PIWI_AI_OPTIONAL_PROBE_TIMEOUT",
+  aiResponseWaitTimeout: "PIWI_AI_RESPONSE_WAIT_TIMEOUT",
+  aiScreenshotFallback: "PIWI_AI_SCREENSHOT_FALLBACK"
+};
+var PIWI_PROBE_ENV = {
+  flag: "PIWI_PROBE",
+  plan: "PIWI_PROBE_PLAN",
+  results: "PIWI_PROBE_RESULTS",
+  secret: "PIWI_PROBE_SECRET"
+};
+var ENV_FALLBACK_SPECS = [
+  { option: "serverUrl", env: PIWI_ENV_KEYS.serverUrl, kind: "string" },
+  { option: "projectName", env: PIWI_ENV_KEYS.projectName, kind: "string" },
+  { option: "apiKey", env: PIWI_ENV_KEYS.apiKey, kind: "string" },
+  { option: "username", env: PIWI_ENV_KEYS.username, kind: "string" },
+  { option: "password", env: PIWI_ENV_KEYS.password, kind: "string" },
+  { option: "environment", env: PIWI_ENV_KEYS.environment, kind: "string" },
+  { option: "label", env: PIWI_ENV_KEYS.label, kind: "string" },
+  { option: "runLabel", env: PIWI_ENV_KEYS.runLabel, kind: "string" },
+  { option: "keep", env: PIWI_ENV_KEYS.keep, kind: "bool" },
+  { option: "streaming", env: PIWI_ENV_KEYS.streaming, kind: "bool" },
+  { option: "streamingBatchSize", env: PIWI_ENV_KEYS.streamingBatchSize, kind: "number" },
+  { option: "streamingBatchDelay", env: PIWI_ENV_KEYS.streamingBatchDelay, kind: "number" },
+  { option: "maxStreamBufferBytes", env: PIWI_ENV_KEYS.maxStreamBufferBytes, kind: "number" },
+  { option: "liveFileUploads", env: PIWI_ENV_KEYS.liveFileUploads, kind: "bool" },
+  { option: "failOnFlakyTests", env: PIWI_ENV_KEYS.failOnFlakyTests, kind: "bool" },
+  { option: "uploadTraces", env: PIWI_ENV_KEYS.uploadTraces, kind: "bool" },
+  { option: "uploadReport", env: PIWI_ENV_KEYS.uploadReport, kind: "bool" },
+  { option: "captureLocators", env: PIWI_ENV_KEYS.captureLocators, kind: "bool" },
+  { option: "capturePageState", env: PIWI_ENV_KEYS.capturePageState, kind: "bool" },
+  { option: "capturePageInventory", env: PIWI_ENV_KEYS.capturePageInventory, kind: "bool" },
+  { option: "captureServerTraces", env: PIWI_ENV_KEYS.captureServerTraces, kind: "bool" },
+  { option: "sampleAriaOnPass", env: PIWI_ENV_KEYS.sampleAriaOnPass, kind: "bool" },
+  { option: "uploadManifest", env: PIWI_ENV_KEYS.uploadManifest, kind: "bool" },
+  { option: "defaultCapture", env: PIWI_ENV_KEYS.defaultCapture, kind: "bool" },
+  { option: "inspectOnFailure", env: PIWI_ENV_KEYS.inspectOnFailure, kind: "bool" },
+  { option: "pickLocatorOnFailure", env: PIWI_ENV_KEYS.pickLocatorOnFailure, kind: "bool" },
+  { option: "outputFile", env: PIWI_ENV_KEYS.outputFile, kind: "string" }
+];
+
+// src/cli/probe.ts
+var EXIT_OK4 = 0;
+var EXIT_ERROR4 = 2;
 var USAGE6 = `
+piwi probe \u2014 run the dashboard's probe plan and record what the suite noticed
+
+Usage:
+  npx @piwitests/reporter probe [options] [-- <playwright args>]
+
+Options:
+  --server-url <url>   Dashboard URL (or PIWI_DASHBOARD_URL)
+  --api-key <key>      Reporter API key (or PIWI_API_KEY)
+  --project <name|id>  Project name or id (or PIWI_PROJECT_NAME)
+  --budget <n>         Max pairs to probe this run (default the server's)
+
+Everything after \`--\` is passed to \`playwright test\`.
+`.trim();
+function readOption6(argv, name) {
+  const i = argv.indexOf(name);
+  return i >= 0 && i + 1 < argv.length ? argv[i + 1] : void 0;
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function resolvePlaywrightCli2() {
+  const require2 = (0, import_node_module3.createRequire)(path12.join(process.cwd(), "noop.js"));
+  for (const id of ["playwright/cli", "@playwright/test/cli", "playwright/lib/cli/cli"]) {
+    try {
+      return require2.resolve(id);
+    } catch {
+    }
+  }
+  return null;
+}
+function spawnPlaywright2(playwrightArgs, env) {
+  const cli = resolvePlaywrightCli2();
+  const child = cli ? (0, import_node_child_process4.spawn)(process.execPath, [cli, "test", ...playwrightArgs], { stdio: "inherit", env }) : (0, import_node_child_process4.spawn)(process.platform === "win32" ? "npx.cmd" : "npx", ["playwright", "test", ...playwrightArgs], {
+    stdio: "inherit",
+    env
+  });
+  return new Promise((resolve6) => {
+    child.on("error", (err) => {
+      console.error(`piwi probe: could not start Playwright \u2014 ${err.message}`);
+      resolve6(EXIT_ERROR4);
+    });
+    child.on("exit", (code) => resolve6(code ?? EXIT_ERROR4));
+  });
+}
+async function runProbe(argv) {
+  const sep3 = argv.indexOf("--");
+  const own = sep3 < 0 ? argv : argv.slice(0, sep3);
+  const playwrightArgs = sep3 < 0 ? [] : argv.slice(sep3 + 1);
+  if (own.includes("-h") || own.includes("--help")) {
+    console.log(USAGE6);
+    return EXIT_OK4;
+  }
+  const env = process.env;
+  const serverUrl = (readOption6(own, "--server-url") ?? env.PIWI_DASHBOARD_URL ?? "").replace(/\/$/, "");
+  if (!serverUrl) {
+    console.error("piwi probe: no dashboard URL \u2014 pass --server-url or set PIWI_DASHBOARD_URL");
+    return EXIT_ERROR4;
+  }
+  const apiKey = readOption6(own, "--api-key") ?? env.PIWI_API_KEY ?? null;
+  const project = readOption6(own, "--project") ?? env.PIWI_PROJECT_NAME ?? "";
+  const budget = readOption6(own, "--budget");
+  let projectId;
+  try {
+    projectId = await resolveProjectId({ serverUrl, apiKey, project, key: "" });
+  } catch (e) {
+    console.error(`piwi probe: ${e.message}`);
+    return EXIT_ERROR4;
+  }
+  const authHeaders2 = apiKey ? { "X-API-Key": apiKey } : {};
+  const planUrl = `${serverUrl}/api/projects/${projectId}/probes/plan${budget ? `?budget=${encodeURIComponent(budget)}` : ""}`;
+  let plan;
+  try {
+    const res = await fetch(planUrl, { headers: authHeaders2 });
+    if (!res.ok) throw new Error(`dashboard returned ${res.status}`);
+    plan = await res.json();
+  } catch (e) {
+    console.error(`piwi probe: could not fetch the probe plan \u2014 ${e.message}`);
+    return EXIT_ERROR4;
+  }
+  if (!plan.items || plan.items.length === 0) {
+    console.error("piwi probe: nothing to probe \u2014 the plan is empty.");
+    return EXIT_OK4;
+  }
+  console.error(`piwi probe: ${plan.items.length} pair(s) to probe (budget ${plan.budget}).`);
+  const dir = fs10.mkdtempSync(path12.join(os2.tmpdir(), "piwi-probe-"));
+  const planFile = path12.join(dir, "plan.json");
+  const resultsFile = path12.join(dir, "results.jsonl");
+  const runOutputFile = path12.join(dir, "run.json");
+  fs10.writeFileSync(planFile, JSON.stringify(plan));
+  fs10.writeFileSync(resultsFile, "");
+  const grep = plan.items.map((i) => i.testTitle).filter(Boolean).map(escapeRegex).join("|");
+  const pwArgs = [...playwrightArgs];
+  if (grep && !playwrightArgs.includes("--grep") && !playwrightArgs.includes("-g")) pwArgs.push("--grep", grep);
+  const childEnv = {
+    ...env,
+    [PIWI_PROBE_ENV.flag]: "1",
+    [PIWI_PROBE_ENV.plan]: planFile,
+    [PIWI_PROBE_ENV.results]: resultsFile,
+    // The reporter creates the probe run and knows its server-assigned id; have
+    // it write the run output here so the results POST can name the run.
+    [PIWI_ENV_KEYS.outputFile]: runOutputFile
+  };
+  await spawnPlaywright2(pwArgs, childEnv);
+  const lines = fs10.readFileSync(resultsFile, "utf8").split("\n").filter(Boolean);
+  const results = [];
+  for (const line of lines) {
+    try {
+      results.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  if (results.length === 0) {
+    console.error("piwi probe: no probe outcomes were recorded (are the Piwi capture fixtures active?).");
+    return EXIT_OK4;
+  }
+  let runId = null;
+  try {
+    const out = JSON.parse(fs10.readFileSync(runOutputFile, "utf8"));
+    if (typeof out.runId === "number") runId = out.runId;
+  } catch {
+  }
+  try {
+    const res = await fetch(`${serverUrl}/api/projects/${projectId}/probes/results`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...authHeaders2 },
+      body: JSON.stringify({ runId, results })
+    });
+    if (!res.ok) throw new Error(`dashboard returned ${res.status}`);
+    const body = await res.json();
+    const noticed = results.filter((r) => r.outcome === "noticed").length;
+    const notNoticed = results.filter((r) => r.outcome === "not-noticed").length;
+    console.error(
+      `piwi probe: recorded ${body.recorded ?? results.length} outcome(s) \u2014 ${noticed} noticed, ${notNoticed} not noticed.`
+    );
+  } catch (e) {
+    console.error(`piwi probe: could not post probe results \u2014 ${e.message}`);
+    return EXIT_ERROR4;
+  }
+  return EXIT_OK4;
+}
+
+// src/cli/quality-report.ts
+var fs11 = __toESM(require("fs"));
+var EXIT_OK5 = 0;
+var EXIT_VERDICT = 1;
+var EXIT_ERROR5 = 2;
+var FORMATS = ["md", "json", "html", "pdf", "csv"];
+var DASHBOARDS = ["executive", "engineering", "overview"];
+var USAGE7 = `
+piwi report \u2014 print a quality report from the dashboard
+
+Usage:
+  npx @piwitests/reporter report [options]
+
+Connection:
+  --server-url <url>     Dashboard URL                 (env PIWI_DASHBOARD_URL)
+  --api-key <key>        API key                       (env PIWI_API_KEY)
+
+What to report:
+  --project <names|ids>  Comma-separated projects (default: every project you can see)
+  --period <period>      7d, 30d (default), last-month, this-quarter, 2026-08-01..2026-08-31, \u2026
+  --compare <mode>       previous (default), year, none
+  --dashboard <name>     executive (default), engineering, overview
+  --branch <names>       Comma-separated branches (default: each project's default branch)
+  --environment <names>  Comma-separated environments
+  --selection <key>      Only the tests of this selection
+  --lang <code>          Report language, such as en or fr (default: the dashboard's default)
+
+Output:
+  --format <fmt>         md (default), json, html, pdf, csv
+  --output <file>        Write to a file instead of stdout (required for pdf)
+  --fail-on <tone>       Exit 1 when the verdict is bad, or mixed or bad (--fail-on mixed)
+  -h, --help             Show this help
+
+Exit codes: 0 written, 1 written and the verdict is at or below --fail-on, 2 no report.
+`.trim();
+function readOption7(argv, name) {
+  const withEquals = argv.find((arg) => arg.startsWith(`${name}=`));
+  if (withEquals) return withEquals.slice(name.length + 1);
+  const index = argv.indexOf(name);
+  if (index === -1) return void 0;
+  const value = argv[index + 1];
+  return value && !value.startsWith("--") ? value : void 0;
+}
+function normalizePeriod(raw) {
+  const days = raw.trim().match(/^(\d+)d$/);
+  return days ? `last-${days[1]}d` : raw.trim();
+}
+function parseReportArgs(argv, env) {
+  const serverUrl = (readOption7(argv, "--server-url") ?? env.PIWI_DASHBOARD_URL ?? "").replace(/\/$/, "");
+  if (!serverUrl) throw new Error("No dashboard URL \u2014 pass --server-url or set PIWI_DASHBOARD_URL");
+  const format = (readOption7(argv, "--format") ?? "md").toLowerCase();
+  if (!FORMATS.includes(format)) {
+    throw new Error(`--format must be one of ${FORMATS.join(", ")}, got "${format}"`);
+  }
+  const dashboard = readOption7(argv, "--dashboard") ?? "executive";
+  if (!DASHBOARDS.includes(dashboard)) {
+    throw new Error(`--dashboard must be one of ${DASHBOARDS.join(", ")}, got "${dashboard}"`);
+  }
+  const lang = readOption7(argv, "--lang") ?? null;
+  if (lang !== null && !/^[a-z]{2,3}(-[a-z0-9]{2,8})*$/i.test(lang)) {
+    throw new Error(`--lang must be a language code such as en or fr, got "${lang}"`);
+  }
+  const failOn = readOption7(argv, "--fail-on") ?? null;
+  if (failOn !== null && failOn !== "bad" && failOn !== "mixed") {
+    throw new Error(`--fail-on must be bad or mixed, got "${failOn}"`);
+  }
+  const output = readOption7(argv, "--output") ?? null;
+  if (format === "pdf" && !output) throw new Error("A PDF needs --output <file>");
+  return {
+    serverUrl,
+    apiKey: readOption7(argv, "--api-key") ?? env.PIWI_API_KEY ?? null,
+    projects: (readOption7(argv, "--project") ?? "").split(",").map((p) => p.trim()).filter(Boolean),
+    period: normalizePeriod(readOption7(argv, "--period") ?? "30d"),
+    compare: readOption7(argv, "--compare") ?? null,
+    dashboard,
+    branches: readOption7(argv, "--branch") ?? null,
+    environments: readOption7(argv, "--environment") ?? null,
+    selection: readOption7(argv, "--selection") ?? null,
+    lang,
+    format,
+    output,
+    failOn
+  };
+}
+function reportQuery(args, projectIds, format) {
+  const q = new URLSearchParams({ dashboard: args.dashboard, format, period: args.period });
+  if (projectIds.length > 0) q.set("projects", projectIds.join(","));
+  if (args.compare) q.set("compare", args.compare);
+  if (args.branches) q.set("branches", args.branches);
+  if (args.environments) q.set("environments", args.environments);
+  if (args.selection) q.set("sel", args.selection);
+  if (args.lang) q.set("lang", args.lang);
+  return q;
+}
+function failsOn(tone, failOn) {
+  if (!failOn) return false;
+  return failOn === "mixed" ? tone !== "good" : tone === "bad";
+}
+async function fetchReport(args, query) {
+  const res = await fetch(`${args.serverUrl}/api/reports/preview?${query}`, {
+    headers: args.apiKey ? { "X-API-Key": args.apiKey } : {}
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body.message || `Dashboard returned ${res.status}`);
+  }
+  return res;
+}
+async function runQualityReport(argv) {
+  if (argv.includes("-h") || argv.includes("--help")) {
+    console.log(USAGE7);
+    return EXIT_OK5;
+  }
+  try {
+    const args = parseReportArgs(argv, process.env);
+    const projectIds = [];
+    for (const project of args.projects) {
+      projectIds.push(await resolveProjectId({ serverUrl: args.serverUrl, apiKey: args.apiKey, project, key: "" }));
+    }
+    const res = await fetchReport(args, reportQuery(args, projectIds, args.format));
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    if (args.output) fs11.writeFileSync(args.output, bytes);
+    else process.stdout.write(bytes);
+    if (!args.failOn) return EXIT_OK5;
+    const bundle = args.format === "json" ? JSON.parse(new TextDecoder().decode(bytes)) : await (await fetchReport(args, reportQuery(args, projectIds, "json"))).json();
+    if (failsOn(bundle.verdict.tone, args.failOn)) {
+      console.error(`piwi report: the verdict is ${bundle.verdict.tone}`);
+      return EXIT_VERDICT;
+    }
+    return EXIT_OK5;
+  } catch (e) {
+    console.error(`piwi report: ${e.message}`);
+    return EXIT_ERROR5;
+  }
+}
+
+// src/cli/index.ts
+var USAGE8 = `
 piwi \u2014 companion commands for the Piwi Dashboard reporter
 
 Usage:
@@ -1686,8 +2092,10 @@ Commands:
   init      Wire a Playwright project up to a Piwi Dashboard
   skills    Install the Piwi agent skills into this project
   gate      Fail a CI job on the dashboard's analysis of a run
+  report    Print a quality report (Markdown, PDF, HTML, CSV or JSON)
   select    Print the Playwright args for a saved test selection
   run       Run a saved test selection with playwright test
+  probe     Run the dashboard's probe plan and record what the suite noticed
   ai        Manage committed natural-language AI-step artifacts
 
 Run \`npx @piwitests/reporter <command> --help\` for a command's options.
@@ -1703,21 +2111,25 @@ async function main() {
       return runSkills(rest, findTemplatesDir(__dirname));
     case "gate":
       return runGate(rest);
+    case "report":
+      return runQualityReport(rest);
     case "select":
       return runSelect(rest);
     case "run":
       return runRun(rest);
+    case "probe":
+      return runProbe(rest);
     case "ai":
       return runAi(rest);
     case void 0:
     case "-h":
     case "--help":
-      console.log(USAGE6);
+      console.log(USAGE8);
       return 0;
     default:
       console.error(`piwi: unknown command "${command}"
 `);
-      console.error(USAGE6);
+      console.error(USAGE8);
       return 2;
   }
 }