ravensight-playtest 0.2.9 → 0.3.1

package/src/commands/check.js

@@ -10,6 +10,10 @@ import { inspectGodot } from '../godot.js';
 import { CLI_VERSION, compareVersions } from '../version.js';
 import { ui } from '../ui/index.js';
 import { ExitCode } from '../errors.js';
+import { completenessFor } from './brief.js';
+import { WEBDRIVER_NAMES } from '../run/drivers/webdriver.js';
+import { inspectNativeBuild, probeAutomation, platformWords } from '../run/drivers/webdriver-probe.js';
+import path from 'node:path';
 
 export const NODE_MIN_MAJOR = 22;
 const DISK_WARN_BYTES = 2 * 1024 * 1024 * 1024;
@@ -88,6 +92,96 @@ export async function probeBrowser(importer) {
   }
 }
 
+/** Said by `check` every time, in both outputs, because a customer asked. */
+export const NO_CHARGE_NOTE = 'check reserves no units and starts no job: every request it makes is a free read, and the automation probe talks only to your own local server.';
+
+/** `Jump Bunny (g1)`, or just the id when the game has no name. */
+const gameLabel = game => (game.name ? `${game.name} (${game.gameId})` : game.gameId);
+
+/**
+ * The driver this directory would run with, and the target it would point at,
+ * resolved the way `run` resolves them. The flag wins, then the repo config.
+ *
+ * @param {Object} flags
+ * @param {Object|null} config
+ * @returns {{driverName: string, native: boolean, target: string|null}}
+ */
+export function plannedRun(flags = {}, config = null) {
+  const driverName = flags.driver || (config && config.driver) || 'playwright_web';
+  const build = (config && config.build) || {};
+  let target = null;
+  if (WEBDRIVER_NAMES.includes(driverName) || driverName === 'cli_stdio') {
+    target = flags.driverConfig || (build.kind === 'driver_config' ? build.ref : null) || null;
+  } else if (driverName === 'playwright_web') {
+    target = flags.buildUrl || (build.kind === 'url' ? build.ref : null) || null;
+  } else if (driverName === 'godot_driver') {
+    target = flags.godotProject || (build.kind === 'godot_project' ? build.ref : null) || null;
+  }
+  return { driverName, native: WEBDRIVER_NAMES.includes(driverName), target };
+}
+
+/**
+ * The automation rows: the native build, then the automation server. These
+ * are the rows `run` repeats as its preflight before it registers a native job,
+ * so they take nothing from the account and need no token.
+ *
+ * @param {{driverName: string, target: string|null, repoRoot?: string}} plan
+ * @param {{fetch?: typeof fetch, probeAutomation?: Function, timeouts?: Object}} [deps]
+ * @returns {Promise<{rows: Array, automation: Object, build: Object}>}
+ */
+export async function automationChecks(plan, deps = {}) {
+  const repoRoot = plan.repoRoot || process.cwd();
+  const targetPath = plan.target ? path.resolve(repoRoot, plan.target) : null;
+  const words = platformWords(plan.driverName);
+  const onRow = deps.onRow || (() => {});
+  const rows = [];
+  const add = entry => {
+    rows.push(entry);
+    onRow(entry);
+  };
+
+  const build = await inspectNativeBuild({ target: targetPath, repoRoot, driverName: plan.driverName });
+  add(row('build', build.status, build.detail, build.fix));
+
+  const probe = await (deps.probeAutomation || probeAutomation)({
+    driverName: plan.driverName,
+    target: targetPath,
+    fetch: deps.fetch,
+    timeouts: deps.timeouts,
+    onProgress: deps.onProgress
+  });
+  const fixes = {
+    config: 'write a driver config with a loopback endpoint and W3C capabilities; see docs/NATIVE_RUNNER.md',
+    reachable: 'start your local W3C automation server (see docs/NATIVE_RUNNER.md) and confirm the endpoint in the driver config',
+    session: words.session,
+    session_timeout: 'restart the automation server, or wait for it to finish, then run check again before starting a run',
+    app: words.app
+  };
+  if (probe.failed) {
+    add(row('automation server', 'fail', probe.detail, fixes[probe.failed]));
+  } else if (probe.closed === false) {
+    add(row(
+      'automation server',
+      'warn',
+      probe.detail,
+      'the probe session could not be closed; restart the automation server if the device stays busy'
+    ));
+  } else {
+    add(row('automation server', 'pass', probe.detail));
+  }
+
+  return {
+    rows,
+    build: { ref: build.ref, status: build.status },
+    automation: {
+      endpoint: probe.endpoint,
+      reachable: probe.reachable,
+      session: probe.session,
+      app: probe.app
+    }
+  };
+}
+
 /**
  * Every environment check, as data.
  *
@@ -96,30 +190,50 @@ export async function probeBrowser(importer) {
  * in process server with no terminal involved.
  *
  * Status meanings are load bearing. `fail` is "this command cannot work", and
- * it is what sets exit code 3. `warn` is "something optional is missing", and
- * CI must not fail on it: ffmpeg and Godot are genuinely optional, and a run
- * that never touches them should not be blocked because they are absent.
+ * it is what sets exit code 3. `warn` is "something optional is missing, or
+ * could not be checked", and CI must not fail on it: ffmpeg and Godot are
+ * genuinely optional, and a run that never touches them should not be blocked
+ * because they are absent. `pass` is checked and fine.
+ *
+ * The setup rows are separate on purpose: CLI version, login, project binding,
+ * brief, build and (for a native driver) the automation server. A customer was
+ * told login was still needed when the login was fine and the missing piece
+ * was the automation server; each row now answers one question.
+ *
+ * Nothing here reserves units or starts a job. The estimate, whoami, brief and
+ * pack requests are reads.
  *
  * @param {Object} [flags]
  * @param {string} [flags.apiUrl]
  * @param {string} [flags.game]
+ * @param {string} [flags.driver]
+ * @param {string} [flags.driverConfig]
  * @param {string[]} [flags.modules]
  * @param {string[]} [flags.personas]
  * @param {string} [flags.repoRoot]
  * @param {boolean} [flags.web] probe the browser whatever the config says
  * @param {Object} [deps]
- * @returns {Promise<{rows: Array, ok: boolean}>}
+ * @returns {Promise<{rows: Array, ok: boolean, cli: Object, login: Object, project: Object, brief: Object, build: Object, automation: Object|null}>}
  */
 export async function runChecks(flags = {}, deps = {}) {
   const apiUrl = flags.apiUrl || resolveApiUrl();
+  const repoRoot = flags.repoRoot || process.cwd();
   const rows = [];
+  const facts = {
+    cli: { installed: CLI_VERSION, latest: null, min_supported: null },
+    login: { present: false, valid: false, games: [] },
+    project: { game: null, environment: null, in_scope: null },
+    brief: { present: null, complete: null, missing: [] },
+    build: { driver: null, ref: null },
+    automation: null
+  };
 
   /* ------------------------------------------------------------- runtime */
 
   const nodeMajor = Number(process.versions.node.split('.')[0]);
   rows.push(row(
     'node',
-    nodeMajor >= NODE_MIN_MAJOR ? 'ok' : 'fail',
+    nodeMajor >= NODE_MIN_MAJOR ? 'pass' : 'fail',
     `v${process.versions.node}`,
     `install Node ${NODE_MIN_MAJOR} or newer`
   ));
@@ -130,7 +244,7 @@ export async function runChecks(flags = {}, deps = {}) {
   let version = null;
   try {
     version = await api.cli.version();
-    rows.push(row('api reachable', 'ok', `${apiUrl} (schema ${version.schema_version})`));
+    rows.push(row('api reachable', 'pass', `${apiUrl} (schema ${version.schema_version})`));
   } catch (error) {
     rows.push(row(
       'api reachable',
@@ -140,15 +254,27 @@ export async function runChecks(flags = {}, deps = {}) {
     ));
   }
 
+  /* --------------------------------------------------------- cli version */
+
   if (version) {
+    facts.cli.latest = version.latest || null;
+    facts.cli.min_supported = version.min_supported || null;
     const tooOld = compareVersions(CLI_VERSION, version.min_supported) < 0;
     const behind = compareVersions(CLI_VERSION, version.latest) < 0;
+    const ahead = compareVersions(CLI_VERSION, version.latest) > 0;
     rows.push(row(
       'cli version',
-      tooOld ? 'fail' : behind ? 'warn' : 'ok',
-      `${CLI_VERSION} (server wants at least ${version.min_supported}, latest ${version.latest})`,
+      tooOld ? 'fail' : behind ? 'warn' : 'pass',
+      `installed ${CLI_VERSION}; server latest ${version.latest}, min_supported ${version.min_supported}${ahead ? ' (installed is newer than the server lists)' : ''}`,
       tooOld || behind ? 'npm install -g ravensight-playtest@latest' : null
     ));
+  } else {
+    rows.push(row(
+      'cli version',
+      'warn',
+      `installed ${CLI_VERSION}; the server's latest and min_supported could not be read`,
+      'fix api reachable, then run check again'
+    ));
   }
 
   /* ------------------------------------------------------- the credential */
@@ -169,138 +295,223 @@ export async function runChecks(flags = {}, deps = {}) {
   };
   rows.push(row(
     'credential store',
-    'ok',
+    'pass',
     storeDetail(),
     source === 'file' || (source === null && backend === 'file')
       ? 'install libsecret for a real keychain on Linux'
       : null
   ));
 
+  /* ---------------------------------------------------------------- login */
+
+  facts.login.present = Boolean(token);
+  let whoami = null;
+  let authed = null;
   if (looksLikeIngestKey(token)) {
     rows.push(row(
-      'token valid',
+      'login',
       'fail',
       'that is an ingest key, not a CLI token',
       'run login, or set RAVENSIGHT_TOKEN to a gt_cli_ token'
     ));
   } else if (looksLikeMcpToken(token)) {
     rows.push(row(
-      'token valid',
+      'login',
       'fail',
       'This is an MCP personal access token (gt_mcp_). The CLI needs its own token (gt_cli_): run `ravensight-playtest login`, or set RAVENSIGHT_TOKEN to a gt_cli_ token in CI.',
       'ravensight-playtest login'
     ));
   } else if (!token) {
-    rows.push(row('token valid', 'fail', `not logged in to ${host}`, 'ravensight-playtest login'));
-  }
-
-  let whoami = null;
-  if (token && !looksLikeIngestKey(token) && !looksLikeMcpToken(token)) {
-    const authed = deps.authedApi || createClient({ apiUrl, token });
+    rows.push(row('login', 'fail', `not logged in to ${host}`, 'ravensight-playtest login'));
+  } else {
+    authed = deps.authedApi || createClient({ apiUrl, token });
     try {
       whoami = await authed.cli.whoami();
+      const games = whoami.games || [];
+      facts.login.valid = true;
+      facts.login.games = games.map(game => ({ gameId: game.gameId, name: game.name || null }));
+      const who = whoami.user.email || whoami.user.name || whoami.user.id;
       rows.push(row(
-        'token valid',
-        'ok',
-        `${whoami.user.email || whoami.user.name || whoami.user.id}, scopes ${whoami.scopes.join(' ')}`
+        'login',
+        games.length > 0 ? 'pass' : 'warn',
+        games.length > 0
+          ? `${who}, valid, scoped to ${plural(games.length, 'game')}: ${games.map(gameLabel).join(', ')}`
+          : `${who}, valid, but scoped to no games`,
+        games.length > 0 ? null : 'run ravensight-playtest login again and approve the game for this token'
       ));
     } catch (error) {
       const message = error instanceof ApiError ? error.message : String(error && error.message);
-      rows.push(row('token valid', 'fail', message, 'ravensight-playtest login'));
+      // Only a 401 or 403 is the server refusing the token. A network error or
+      // a 5xx says nothing about the token, so it must not send anyone to log
+      // in again over a login that may be fine.
+      const refused = error instanceof ApiError && (error.status === 401 || error.status === 403);
+      facts.login.valid = refused ? false : null;
+      rows.push(refused
+        ? row('login', 'fail', `a token is stored but the server refused it: ${message}`, 'ravensight-playtest login')
+        : row('login', 'warn', `a token is stored, and the server could not verify it right now: ${message}`, 'check api reachable, then run check again'));
     }
+  }
 
-    /* ------------------------------------------------------------ the game */
-
-    const config = flags.config === undefined
-      ? await loadConfig({ repoRoot: flags.repoRoot })
-      : flags.config;
-    const gameId = flags.game || (config && config.game_id) || null;
+  /* ------------------------------------------------------ project binding */
 
-    if (!gameId) {
+  const config = flags.config === undefined
+    ? await loadConfig({ repoRoot: flags.repoRoot })
+    : flags.config;
+  const gameId = flags.game || (config && config.game_id) || null;
+  let inScope = null;
+  if (!gameId) {
+    rows.push(row(
+      'project binding',
+      'warn',
+      'this directory is not linked to a game',
+      'ravensight-playtest init --game <gameId>'
+    ));
+  } else {
+    const scoped = whoami ? (whoami.games || []).find(game => game.gameId === gameId) : null;
+    const environment = (scoped && scoped.environment) || (config && config.environment) || null;
+    facts.project.game = gameId;
+    facts.project.environment = environment;
+    const linked = `${scoped ? gameLabel(scoped) : gameId}${environment ? `, environment ${environment}` : ''}`;
+    if (!whoami) {
       rows.push(row(
-        'game linked',
+        'project binding',
         'warn',
-        'this directory is not linked to a game',
-        'ravensight-playtest init --game <gameId>'
+        `linked to ${linked}; whether the token can reach it is unknown until login passes`,
+        'fix the login row, then run check again'
       ));
-    } else if (whoami) {
-      const visible = (whoami.games || []).some(game => game.gameId === gameId);
+    } else {
+      inScope = Boolean(scoped);
+      facts.project.in_scope = inScope;
       rows.push(row(
-        'game visible',
-        visible ? 'ok' : 'fail',
-        visible ? gameId : `${gameId} is not visible to this token`,
-        visible ? null : 'approve this game for the token, or run login again'
+        'project binding',
+        inScope ? 'pass' : 'fail',
+        inScope ? `linked to ${linked}, in the token's scope` : `linked to ${linked}, which is not in this token's scope`,
+        inScope ? null : 'run ravensight-playtest login again and approve this game, or relink with init --game <gameId> --force'
       ));
+    }
+  }
+
+  /* ---------------------------------------------------------------- brief */
 
-      /* -------------------------------------------------- balance vs price */
-
-      if (visible) {
-        const modules = flags.modules || (config && config.modules) || ['game_profile', 'persona_playtest'];
-        const personas = flags.personas || (config && config.personas) || [];
-        try {
-          const estimate = await authed.jobs.estimate(gameId, { modules, personas });
-          if (estimate.balance_cents === null || estimate.balance_cents === undefined) {
-            rows.push(row(
-              'balance',
-              'warn',
-              `estimate ${ui.money(estimate.estimate_cents)}, balance hidden by your role`,
-              'ask an owner or admin to check the balance'
-            ));
-          } else {
-            rows.push(row(
-              'balance',
-              estimate.ok ? 'ok' : 'fail',
-              `estimate ${ui.money(estimate.estimate_cents)}, available ${ui.money(estimate.balance_cents)}`,
-              estimate.ok ? null : `top up at ${estimate.topup_url}`
-            ));
-          }
-          // Not a failure and not hidden by role: a job this size is still
-          // allowed, it may just outrun its wall clock, which is worth seeing
-          // here rather than only after `run` has already asked for a price.
-          if (estimate.wall_warning) {
-            rows.push(row('persona wall clock', 'warn', estimate.wall_warning));
-          }
-        } catch (error) {
-          rows.push(row(
-            'balance',
-            'warn',
-            error instanceof ApiError ? error.message : String(error && error.message)
-          ));
-        }
-
-        /* ------------------------------------------------------ pack cache */
-
-        try {
-          const pack = await packs.get({ api: authed, gameId, modules });
-          const manifest = (await authed.packs.manifest()).body;
-          const verified = packs.verifyAgainstManifest(manifest, pack.bundle);
-          rows.push(row(
-            'content pack',
-            verified.ok ? 'ok' : 'fail',
-            verified.ok
-              ? `${plural(pack.bundle.personas.length, 'persona')}, ${plural(verified.checked, 'component')} verified${pack.stale ? ' (cached)' : ''}`
-              : `these components do not match the manifest: ${verified.mismatched.join(', ')}`,
-            verified.ok ? null : `delete ${paths.packCacheDir(apiUrl)} and run check again`
-          ));
-        } catch (error) {
-          rows.push(row(
-            'content pack',
-            'fail',
-            error instanceof ApiError ? error.message : String(error && error.message),
-            'the CLI cannot run without personas and schemas'
-          ));
-        }
+  if (gameId && whoami && inScope) {
+    try {
+      const answer = await authed.brief.get(gameId);
+      const current = (answer && answer.brief) || null;
+      if (!current) {
+        facts.brief = { present: false, complete: false, missing: [] };
+        rows.push(row('brief', 'fail', 'this game has no expectations brief, and a persona run needs one', 'ravensight-playtest brief'));
+      } else {
+        const completeness = completenessFor(current.fields || {});
+        // The server's status is what `run` and `POST /jobs` act on. The local
+        // field check only explains a draft, or flags a brief marked complete
+        // whose fields a persona needs are empty.
+        const complete = current.status === 'complete';
+        facts.brief = { present: true, complete, missing: completeness.missing };
+        const empty = completeness.missing.length ? `; empty: ${completeness.missing.join(', ')}` : '';
+        rows.push(row(
+          'brief',
+          !complete ? 'fail' : completeness.missing.length ? 'warn' : 'pass',
+          complete
+            ? `version ${current.version}, complete${empty || ' (goals, success criteria, controls, how to start)'}`
+            : `version ${current.version}, ${current.status}${empty}`,
+          complete && !completeness.missing.length ? null : 'ravensight-playtest brief'
+        ));
       }
+    } catch (error) {
+      rows.push(row(
+        'brief',
+        'warn',
+        `could not read the brief: ${error instanceof ApiError ? error.message : String(error && error.message)}`,
+        'run check again; a run refuses to start without a complete brief'
+      ));
+    }
+  } else {
+    rows.push(row('brief', 'warn', 'not checked: it needs a valid login and a linked game in scope', 'fix the login and project binding rows first'));
+  }
+
+  /* ---------------------------------------------- build and automation */
+
+  const plan = plannedRun(flags, config);
+  facts.build.driver = plan.driverName;
+  if (plan.native) {
+    const native = await automationChecks({ ...plan, repoRoot }, deps);
+    rows.push(...native.rows);
+    facts.build.ref = native.build.ref;
+    facts.automation = native.automation;
+  } else {
+    facts.build.ref = plan.target;
+    rows.push(row(
+      'build',
+      plan.target ? 'pass' : 'warn',
+      plan.target ? `${plan.driverName}: ${plan.target}` : `${plan.driverName}: no build linked yet`,
+      plan.target ? null : 'pass --build-url, --godot-project or --driver-config to run, or set build in .ravensight/config.json'
+    ));
+  }
+
+  /* -------------------------------------------------- balance and pack */
+
+  if (gameId && whoami && inScope) {
+    const modules = flags.modules || (config && config.modules) || ['game_profile', 'persona_playtest'];
+    const personas = flags.personas || (config && config.personas) || [];
+    try {
+      const estimate = await authed.jobs.estimate(gameId, { modules, personas });
+      if (estimate.balance_cents === null || estimate.balance_cents === undefined) {
+        rows.push(row(
+          'balance',
+          'warn',
+          `estimate ${ui.money(estimate.estimate_cents)}, balance hidden by your role`,
+          'ask an owner or admin to check the balance'
+        ));
+      } else {
+        rows.push(row(
+          'balance',
+          estimate.ok ? 'pass' : 'fail',
+          `estimate ${ui.money(estimate.estimate_cents)}, available ${ui.money(estimate.balance_cents)}`,
+          estimate.ok ? null : `top up at ${estimate.topup_url}`
+        ));
+      }
+      // Not a failure and not hidden by role: a job this size is still
+      // allowed, it may just outrun its wall clock, which is worth seeing
+      // here rather than only after `run` has already asked for a price.
+      if (estimate.wall_warning) {
+        rows.push(row('persona wall clock', 'warn', estimate.wall_warning));
+      }
+    } catch (error) {
+      rows.push(row(
+        'balance',
+        'warn',
+        error instanceof ApiError ? error.message : String(error && error.message)
+      ));
+    }
+
+    try {
+      const pack = await packs.get({ api: authed, gameId, modules });
+      const manifest = (await authed.packs.manifest()).body;
+      const verified = packs.verifyAgainstManifest(manifest, pack.bundle);
+      rows.push(row(
+        'content pack',
+        verified.ok ? 'pass' : 'fail',
+        verified.ok
+          ? `${plural(pack.bundle.personas.length, 'persona')}, ${plural(verified.checked, 'component')} verified${pack.stale ? ' (cached)' : ''}`
+          : `these components do not match the manifest: ${verified.mismatched.join(', ')}`,
+        verified.ok ? null : `delete ${paths.packCacheDir(apiUrl)} and run check again`
+      ));
+    } catch (error) {
+      rows.push(row(
+        'content pack',
+        'fail',
+        error instanceof ApiError ? error.message : String(error && error.message),
+        'the CLI cannot run without personas and schemas'
+      ));
     }
   }
 
   /* --------------------------------------------------------- the machine */
 
-  const repoRoot = flags.repoRoot || process.cwd();
   const free = await freeBytes(repoRoot);
   rows.push(row(
     'disk',
-    free === null ? 'warn' : free >= DISK_WARN_BYTES ? 'ok' : 'warn',
+    free === null ? 'warn' : free >= DISK_WARN_BYTES ? 'pass' : 'warn',
     free === null ? 'could not read free space' : `${ui.bytes(free)} free in ${repoRoot}`,
     'screenshots and a video take 50 to 300 MB per run'
   ));
@@ -308,14 +519,14 @@ export async function runChecks(flags = {}, deps = {}) {
   const machine = recommendConcurrency(deps.machine);
   rows.push(row(
     'cpu and memory',
-    'ok',
+    'pass',
     `${machine.cpus} logical cpus, ${machine.freeMemGb} GB free, use concurrency ${machine.recommended}`
   ));
 
   const ffmpeg = await (deps.detectFfmpeg || detectFfmpeg)();
   rows.push(row(
     'ffmpeg (optional)',
-    ffmpeg.path ? 'ok' : 'warn',
+    ffmpeg.path ? 'pass' : 'warn',
     ffmpeg.path ? `${ffmpeg.path}: ${ffmpeg.version}` : 'not found',
     'needed only to re-encode a session video before upload'
   ));
@@ -325,7 +536,7 @@ export async function runChecks(flags = {}, deps = {}) {
     const probe = await probeBrowser(deps.importer);
     rows.push(row(
       'browser',
-      probe.ok ? 'ok' : browserNeed,
+      probe.ok ? 'pass' : browserNeed,
       probe.detail,
       probe.ok ? null : BROWSER_FIX
     ));
@@ -337,7 +548,7 @@ export async function runChecks(flags = {}, deps = {}) {
   );
   rows.push(row(
     'godot (optional)',
-    godot.binary.path ? 'ok' : 'warn',
+    godot.binary.path ? 'pass' : 'warn',
     godot.binary.path
       ? `${godot.binary.path}${godot.binary.version ? `: ${godot.binary.version}` : ''}`
       // The detector's own message says WHY: nothing found at all, versus a
@@ -359,7 +570,7 @@ export async function runChecks(flags = {}, deps = {}) {
     };
     rows.push(row(
       'godot project',
-      godot.matches === false || godot.unknown ? 'warn' : 'ok',
+      godot.matches === false || godot.unknown ? 'warn' : 'pass',
       godot.matches === false
         ? `project asks for ${godot.projectVersion}, found ${godot.binary.version}`
         : godot.unknown
@@ -373,7 +584,7 @@ export async function runChecks(flags = {}, deps = {}) {
     ));
   }
 
-  return { rows, ok: rows.every(entry => entry.status !== 'fail') };
+  return { rows, ok: rows.every(entry => entry.status !== 'fail'), ...facts };
 }
 
 /**
@@ -383,10 +594,22 @@ export async function runChecks(flags = {}, deps = {}) {
  * @returns {Promise<number>} exit code, 3 when anything failed
  */
 export async function check(flags = {}, deps = {}) {
-  const { rows, ok } = await runChecks(flags, deps);
+  const progress = flags.json ? {} : { onProgress: line => ui.info(line) };
+  const { rows, ok, cli, login, project, brief, build, automation } = await runChecks(flags, { ...progress, ...deps });
 
   if (flags.json) {
-    ui.json({ ok, checks: rows });
+    ui.json({
+      ok,
+      reserves_units: false,
+      note: NO_CHARGE_NOTE,
+      cli,
+      login,
+      project,
+      brief,
+      build,
+      automation,
+      checks: rows
+    });
     return ok ? ExitCode.OK : ExitCode.ENVIRONMENT;
   }
 
@@ -397,9 +620,10 @@ export async function check(flags = {}, deps = {}) {
   ]);
   ui.blank();
   for (const entry of rows) {
-    if (entry.status !== 'ok' && entry.fix) ui.info(`${entry.name}: ${entry.fix}`);
+    if (entry.status !== 'pass' && entry.fix) ui.info(`${entry.name}: ${entry.fix}`);
   }
   ui.blank();
+  ui.info(NO_CHARGE_NOTE);
   if (ok) ui.ok('Ready.');
   else ui.error('Some checks failed. Fix the ones above and run check again.');
   return ok ? ExitCode.OK : ExitCode.ENVIRONMENT;