ravensight-playtest 0.7.0 → 0.7.5

package/README.md

@@ -1,9 +1,47 @@
 # ravensight-playtest
 
-Hosted comparisons use a separate command from the local `run`:
+Hosted playtests run your uploaded build on our machines instead of yours. One
+persona plays it twice, once with Standard and once with Jev, and the dashboard
+gets a report for each and a comparison. They use a separate command from the
+local `run`:
 
 ```sh
-ravensight-playtest hosted quote --game GAME --build BUILD --profile PROFILE --persona curious-kid --video --transcript --output hosted-quote.json
+ravensight-playtest hosted run --wait
+ravensight-playtest hosted status ha_...
+ravensight-playtest hosted cancel ha_...
+```
+
+`hosted run` uses the game this directory is linked to (or `--game`), picks the
+newest build that passed its static archive check on a ready profile (or the one
+named by `--build`), asks the server for a quote and prints it: each unit and
+its price, the hosted compute for each mode, the total and what is due now from
+prepaid funds, the expiry, and the statements you accept with it (the refund
+rules for a failed build and for cancellation, no network access for the game,
+the separate validation hold). It asks before it charges. `--yes` answers for
+you, a run with no terminal and no `--yes` is a no, and `--json` needs `--yes`.
+A balance that does not meet the quote's funding requirement stops before the
+question, and nothing is charged.
+
+| Flag | Effect |
+|---|---|
+| `--build <id>` | Use this build instead of the newest ready one. |
+| `--persona <slug>` | The persona for both runs. Default `curious-kid`. |
+| `--video`, `--transcript` | Save video or transcripts of both sessions in their reports. Priced in the quote. |
+| `--wait` | Stay until the run finishes, printing each phase change, then each mode's outcome. |
+| `--game <id>` | Override the linked game. |
+
+The phases are the dashboard's: queued, provisioning, running, capturing,
+analyzing, then report ready, failed or canceled. `hosted status <id>` prints
+the current one (`--wait` to follow it) with each mode's state and findings and
+the dashboard link to the report. With `--wait`, a failed run exits 1 and a
+canceled one exits 10. `hosted cancel <id>` asks first, then requests
+cancellation: work already done follows the accepted policy and unstarted work
+is refunded during settlement.
+
+To review a quote before paying, save it and confirm it later:
+
+```sh
+ravensight-playtest hosted quote --game GAME --build BUILD --profile PROFILE --persona curious-kid --video --output hosted-quote.json
 ravensight-playtest hosted run hosted-quote.json
 ```
 
@@ -11,6 +49,7 @@ The quote names the full Standard then Jev price, prepaid amount, evidence
 options, expiry and refund rules. It charges nothing. `hosted run` confirms
 that saved quote before one admission request. Its durable journal blocks an
 automatic second POST after an uncertain outcome; preserve it for reconciliation.
+Both forms of `hosted run` keep that journal under `.ravensight/hosted-runs/`.
 A charged-blocked acknowledgement does not prove gameplay or a report. This
 command does not top up funds, change local run/report files or ask for model
 proxy permission on the CLI credential.
@@ -27,14 +66,20 @@ The hosted build command source adds a local check before a paid upload:
 
 ```sh
 ravensight-playtest build preflight ./game.zip --format web --entrypoint index.html
-ravensight-playtest build upload ./game.zip --game GAME --profile READY_PROFILE --entrypoint index.html --dry-run
+ravensight-playtest build upload ./game.zip --game GAME --entrypoint index.html --dry-run
+ravensight-playtest build status --game GAME
 ```
 
 `preflight` seeks through bounded ZIP metadata; it does not load a multi-GB
 archive into memory. A saved server profile can be supplied with `--capacity`
-for its declared limits. Upload selects a currently advertised ready profile,
-checks metadata and a streamed checksum, then asks for the separate $0.49
-validation hold before requesting it. The server’s isolated validator remains
+for its declared limits. Upload uses the server's build profile when it
+advertises exactly one; when it advertises several, name one with `--profile`
+and the error lists them. It checks metadata and a streamed checksum, then
+asks for the separate $0.49 validation hold before requesting it. Without a
+terminal to ask in, pass `--yes`: a piped answer is never taken as consent.
+`build status` shows each build's state and, for a build the server's check
+refused, the reason in one sentence and whether its validation hold is still
+to be returned after cleanup. The server’s isolated validator remains
 authoritative. A passing local check does not establish engine, GPU or license
 compatibility.
 
@@ -1070,8 +1115,16 @@ at the current $1 unit price total $2; the displayed server quote is authoritati
 No comparison model call or extra recording fee is added. Use `--upload-video`
 instead of `--record-video` only when you want the videos uploaded for private
 dashboard playback. Recording is silent and captures only the selected game,
-not your desktop. Browser popups and navigation to another origin are blocked
-while recording.
+not your desktop.
+
+A web persona stays on the build, recording or not. A clicked link, a form, a
+script or a server redirect to another site, or to another port on your
+machine, is stopped (a redirect is undone), and a new window is closed. The
+persona is told "Refused: that link leaves the build under test (host). Stay
+on this page and use its controls." and the step counts as one that changed
+nothing. Each attempt is a network note in the report. `localhost`,
+`127.0.0.1` and `[::1]` on the build's own port are the build. Assets and API
+calls the page loads from elsewhere are not affected.
 
 Web recording produces WebM. Graphical Godot recording needs an existing FFmpeg
 installation and produces MP4; a headless Godot run or missing encoder is reported

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ravensight-playtest",
-  "version": "0.7.0",
+  "version": "0.7.5",
   "description": "Local AI playtests and seeded game simulations with reports in Ravensight.",
   "license": "MIT",
   "homepage": "https://ravensight.io/docs/#playtest",
@@ -46,9 +46,9 @@
     "./api": "./src/api/index.js"
   },
   "scripts": {
-    "test": "node --test --test-reporter=spec 'src/**/!(godot-real|web.e2e|scaffold.godot|template3d.godot).test.js'",
+    "test": "node --test --test-reporter=spec 'src/**/!(godot-real|web.e2e|web.containment.e2e|scaffold.godot|template3d.godot).test.js'",
     "test:godot": "node --test --test-reporter=spec src/run/drivers/godot-real.test.js src/create/scaffold.godot.test.js src/create/template3d.godot.test.js",
-    "test:e2e": "node --test --test-reporter=spec src/run/drivers/web.e2e.test.js",
+    "test:e2e": "node --test --test-reporter=spec src/run/drivers/web.e2e.test.js src/run/drivers/web.containment.e2e.test.js",
     "lint": "node scripts/no-dashes.mjs"
   },
   "dependencies": {

package/src/auth/scopes.js

@@ -0,0 +1,36 @@
+/**
+ * The scopes a CLI token carries, checked before anything is charged.
+ *
+ * A token's scopes are fixed when it is approved. A persona run needs
+ * `playtest:model` to play and `playtest:upload` to hand in its report, and
+ * the server only checks each one when the run reaches it: in October a token
+ * without `playtest:upload` registered a paid job, played it, and was refused
+ * at the upload, so the job came back with no report. `whoami` answers with
+ * the token's scopes, so `run` asks first and refuses locally.
+ */
+
+/** What a persona run (`run`, and `fix`'s verify replay) needs. */
+export const RUN_SCOPES = Object.freeze(['playtest:write', 'playtest:model', 'playtest:upload']);
+
+/**
+ * The required scopes a token lacks, or null when its scopes are not known
+ * (an older server's `whoami` does not list them).
+ *
+ * @param {unknown} scopes the `scopes` field of a whoami answer
+ * @param {ReadonlyArray<string>} [required]
+ * @returns {Array<string>|null}
+ */
+export function missingScopes(scopes, required = RUN_SCOPES) {
+  if (!Array.isArray(scopes)) return null;
+  return required.filter(scope => !scopes.includes(scope));
+}
+
+/**
+ * The refusal for a token that lacks what a run needs.
+ *
+ * @param {Array<string>} missing
+ * @returns {string}
+ */
+export function missingScopeMessage(missing) {
+  return `This login cannot run a playtest: its token does not have ${missing.join(', ')}. Log in again with "ravensight-playtest login" and approve the full set of playtest permissions. Nothing was registered or charged.`;
+}

package/src/cli.js

@@ -153,7 +153,7 @@ function withoutFirst(values, value) {
 export function buildProgram() {
   const program = new Command();
   const slot = { code: ExitCode.OK };
-  const hosted = common(program.command('hosted').description('quote and admit a server-hosted Standard/Jev comparison'));
+  const hosted = common(program.command('hosted').description('run a server-hosted Standard and Jev playtest: quote, run, status and cancel'));
   hosted.command('quote')
     .description('save a full hosted quote without charging or admitting a run')
     .requiredOption('--build <id>', 'an existing validated hosted build')
@@ -163,18 +163,43 @@ export function buildProgram() {
     .option('--game <id>', 'game id, overriding this repo’s configuration')
     .addOption(new Option('--standard-provider <name>', 'explicit Standard provider; unavailable choices are refused').choices(['anthropic', 'openai']))
     .option('--video', 'include hosted gameplay video in this quote')
-    .option('--transcript', 'include the hosted transcript in this quote')
     .action(capture(slot, async (options, command) => {
       const { hostedQuote } = await import('./commands/hosted.js');
       return hostedQuote(flagsFrom(command.optsWithGlobals(), { build: options.build, profile: options.profile,
         persona: options.persona, output: options.output, game: options.game, standardProvider: options.standardProvider,
-        video: options.video, transcript: options.transcript }));
+        video: options.video }));
     }));
-  hosted.command('run <quote-file>')
-    .description('confirm the full saved quote and request one hosted admission; never retry an unknown outcome')
-    .action(capture(slot, async (filename, _options, command) => {
-      const { hostedRun } = await import('./commands/hosted.js');
-      return hostedRun(filename, flagsFrom(command.optsWithGlobals()));
+  common(hosted.command('run [quote-file]'))
+    .description('quote the newest ready build (or --build), confirm the price, and start one hosted Standard and Jev run; with a saved quote file, confirm that quote instead. Never retries an unknown outcome')
+    .option('--build <id>', 'a build that passed its static archive check (default: the newest one)')
+    .option('--persona <slug>', 'the persona that plays both runs (default: curious-kid)')
+    .option('--game <id>', 'game id, overriding this repo’s configuration')
+    .option('--video', 'save video of both game sessions in their reports')
+    .option('--wait', 'stay until the report is ready, printing each phase change')
+    .action(capture(slot, async (filename, options, command) => {
+      const { hostedRun, hostedRunDirect } = await import('./commands/hosted.js');
+      if (filename) {
+        const extra = ['build', 'persona', 'game', 'video', 'wait'].filter(name => options[name] !== undefined);
+        if (extra.length) throw new CliError(`A saved quote already fixes its build, persona and options. Drop --${extra.join(', --')}, or run "hosted run" without a quote file.`);
+        return hostedRun(filename, flagsFrom(command.optsWithGlobals()));
+      }
+      return hostedRunDirect(flagsFrom(command.optsWithGlobals(), { build: options.build, persona: options.persona, game: options.game,
+        video: options.video, wait: options.wait }));
+    }));
+  common(hosted.command('status <run-id>'))
+    .description('show the phase of one hosted run (queued, provisioning, running, capturing, analyzing, report ready, failed or canceled), each mode and the report link')
+    .option('--game <id>', 'game id, overriding this repo’s configuration')
+    .option('--wait', 'stay until the run finishes, printing each phase change')
+    .action(capture(slot, async (runId, options, command) => {
+      const { hostedStatus } = await import('./commands/hosted.js');
+      return hostedStatus(runId, flagsFrom(command.optsWithGlobals(), { game: options.game, wait: options.wait }));
+    }));
+  common(hosted.command('cancel <run-id>'))
+    .description('request cancellation of one hosted run; unstarted work is refunded during settlement')
+    .option('--game <id>', 'game id, overriding this repo’s configuration')
+    .action(capture(slot, async (runId, options, command) => {
+      const { hostedCancel } = await import('./commands/hosted.js');
+      return hostedCancel(runId, flagsFrom(command.optsWithGlobals(), { game: options.game }));
     }));
   const build = common(program.command('build').description('check or upload a self-contained hosted game archive'));
   build.command('preflight <archive>')
@@ -186,13 +211,21 @@ export function buildProgram() {
       const { buildPreflight } = await import('./commands/build.js');
       return buildPreflight(archive, flagsFrom(command.optsWithGlobals(), { entrypoint: options.entrypoint, format: options.format, capacity: options.capacity }));
     }));
+  build.command('status [build-id]')
+    .description('show each private hosted build, why a refused one was refused, and whether its hold is still to be returned')
+    .option('--game <id>', 'game id, overriding this repo’s configuration')
+    .action(capture(slot, async (buildId, options, command) => {
+      const { buildStatus } = await import('./commands/build.js');
+      return buildStatus(buildId, flagsFrom(command.optsWithGlobals(), { game: options.game }));
+    }));
   build.command('upload <archive>')
     .description('preflight and stream one private build upload after validation-hold consent')
-    .requiredOption('--profile <version>', 'one currently advertised ready server profile')
+    .option('--profile <version>', 'server build profile to upload under; optional when the server advertises exactly one, otherwise the error lists the choices')
     .requiredOption('--entrypoint <path>', 'entry file inside the ZIP')
     .option('--game <id>', 'game id, overriding this repo’s configuration')
     .option('--journal <file>', 'preserve this original upload intent at the specified path')
     .option('--dry-run', 'inspect and hash the archive without requesting a reservation')
+    .addHelpText('after', '\nThe $0.49 validation hold is asked for at a terminal. Without one, pass --yes\nto accept it; piped input is never taken as consent. See the result with: ravensight-playtest build status')
     .action(capture(slot, async (archive, options, command) => {
       const { buildUpload } = await import('./commands/build.js');
       return buildUpload(archive, flagsFrom(command.optsWithGlobals(), { entrypoint: options.entrypoint, profile: options.profile, game: options.game, journal: options.journal, dryRun: options.dryRun }));

package/src/commands/brief.js

@@ -273,7 +273,7 @@ async function editBrief(context, flags, deps) {
     parentVersion,
     onStale: async version => {
       ui.warn(`The brief moved to version ${version} while you were editing.`);
-      return ui.confirm('Save on top of that version?', { yes: flags.yes });
+      return ui.confirm('Save on top of that version?', { yes: flags.yes, noTerminalMessage: 'No terminal to confirm in: pass --yes to save on top of the newer version.' });
     }
   });
 

package/src/commands/build.js

@@ -4,6 +4,7 @@ import { resolveGameId } from '../config.js';
 import { withAuthHandling } from '../auth/session.js';
 import { preflightBuildArchive, limitsFromProfile } from '../hosted/archivePreflight.js';
 import { uploadHostedBuild } from '../hosted/buildUpload.js';
+import { buildStatusLines, readHostedBuilds } from '../hosted/buildStatus.js';
 import { CliError, ExitCode } from '../errors.js';
 import { ui } from '../ui/index.js';
 
@@ -61,6 +62,7 @@ export async function buildUpload(filename, flags = {}, deps = {}) {
         onPrepared: prepared => {
           progress.stop();
           if (flags.json) return;
+          ui.info(`Build profile: ${prepared.profileVersion}${flags.profile ? '' : ', the only one the server advertises'}.`);
           ui.info(`ZIP metadata checked: ${prepared.entries} entries; ${ui.bytes(prepared.archiveBytes)} archive, ${ui.bytes(prepared.expandedBytes)} expanded.`);
           const limit = prepared.limits;
           ui.info(`Selected limits: archive ${ui.bytes(limit.archiveBytes)}, expanded ${ui.bytes(limit.expandedBytes)}, file ${ui.bytes(limit.fileBytes)}, ${limit.files} entries, depth ${limit.depth}, ratio ${limit.ratio}:1.`);
@@ -73,9 +75,29 @@ export async function buildUpload(filename, flags = {}, deps = {}) {
       });
       progress.stop();
       if (flags.json) ui.json(result);
-      else if (result.state === 'awaiting_validation') ui.ok(`Uploaded ${result.buildId}; awaiting server validation. Journal: ${result.journal}`);
+      else if (result.state === 'awaiting_validation') {
+        ui.ok(`Uploaded ${result.buildId}; awaiting server validation. Journal: ${result.journal}`);
+        ui.info(`See the result, and the reason if it is not accepted: ravensight-playtest build status ${result.buildId}`);
+      }
       else ui.info(result.state === 'declined' ? 'Upload declined; no reservation requested.' : 'Preflight finished; no reservation requested.');
       return result.state === 'declined' ? ExitCode.CANCELED : ExitCode.OK;
     } finally { progress.stop(); }
   });
 }
+
+// State of the game's private hosted builds, with the reason a refused build
+// was refused and whether its validation hold is still to be returned.
+export async function buildStatus(buildId, flags = {}, deps = {}) {
+  const context = deps.context || await createContext({ apiUrl: flags.apiUrl, repoRoot: flags.repoRoot, requireAuth: true });
+  return withAuthHandling(context, async () => {
+    const builds = await readHostedBuilds({ api: context.api, gameId: resolveGameId(flags, context.config), buildId });
+    if (flags.json) { ui.json({ builds }); return ExitCode.OK; }
+    if (!builds.length) {
+      if (buildId) throw new CliError(`No hosted build ${buildId} for this game. A refused build is listed until its cleanup finishes.`);
+      ui.info('No private hosted builds for this game.');
+      return ExitCode.OK;
+    }
+    for (const build of builds) buildStatusLines(build).forEach(text => ui.info(text));
+    return ExitCode.OK;
+  });
+}

package/src/commands/check.js

@@ -3,6 +3,7 @@ import { ApiError } from '../api/errors.js';
 import { resolveApiUrl, paths } from '../paths.js';
 import { resolveToken, looksLikeIngestKey, looksLikeMcpToken } from '../auth/session.js';
 import { backendName } from '../auth/keychain.js';
+import { missingScopes } from '../auth/scopes.js';
 import { loadConfig } from '../config.js';
 import { packs } from '../packs/index.js';
 import { detectFfmpeg, freeBytes, recommendConcurrency } from '../detect.js';
@@ -421,7 +422,10 @@ export async function runChecks(flags = {}, deps = {}) {
       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(
+      const missing = missingScopes(whoami.scopes);
+      if (missing && missing.length > 0) {
+        rows.push(row('login', 'fail', `${who}, valid, but the token does not have ${missing.join(', ')}, so a playtest run would be refused`, 'ravensight-playtest login'));
+      } else rows.push(row(
         'login',
         games.length > 0 ? 'pass' : 'warn',
         games.length > 0

package/src/commands/fakeCore.js

@@ -363,7 +363,11 @@ export function fakeCore({
     runs: {
       async heartbeat(gameId, jobId, runId, options) {
         record('heartbeat', { runId, options });
-        return { run: { usage: { total_usd: 0.11 } }, cancel_requested: false };
+        // calls: 0, so the fake spend never prices a unit: $0.11 over a few
+        // ten-token scripted turns would make the report reserve
+        // (../run/budgetReserve.js) stop play after one turn in tests about
+        // other things. The reserve has its own tests.
+        return { run: { usage: { total_usd: 0.11, calls: 0 } }, cancel_requested: false };
       },
       async transition(gameId, jobId, runId, state, options) {
         record('transition', { runId, state, options });

package/src/commands/fix.js

@@ -13,6 +13,7 @@ import { createHeartbeat } from '../run/heartbeat.js';
 import { createModelClient } from '../run/model.js';
 import { jobDir, runDir as runDirFor, RUN_FILES, screenshotsDir } from '../run/paths.js';
 import { runPersona } from '../run/personaLoop.js';
+import { runModelBudgetUsd } from '../run/budgetReserve.js';
 import { replayTrace } from '../run/replay.js';
 import { loadTrace, replayReport, replaySentence } from './replay.js';
 import { createRepoTools, PROFILE_TOOLS, WRITE_TOOLS } from '../run/repoTools.js';
@@ -1202,6 +1203,7 @@ export async function runVerify({
     outcome = await runPersona({
       client,
       api,
+      modelBudgetUsd: runModelBudgetUsd(entry),
       gameId,
       jobId,
       runId: entry.run_id,

package/src/commands/hosted.js

@@ -3,7 +3,11 @@ import { resolveGameId } from '../config.js';
 import { withAuthHandling } from '../auth/session.js';
 import { CliError, ExitCode } from '../errors.js';
 import { ui } from '../ui/index.js';
-import { quoteHostedRun, runHostedQuote, hostedQuoteLines } from '../hosted/recordedRun.js';
+import { quoteHostedRun, runHostedQuote, hostedQuoteLines, prepareHostedRun, admitHostedOffer, confirmQuestion,
+  hostedConsentLines, fundingShortfall, readHostedRun, cancelHostedRun } from '../hosted/recordedRun.js';
+import { hostedPlaytestStatus, modeOutcomes, modeLine, TERMINAL_PHASES } from '../hosted/status.js';
+import { jobLink } from '../dashboard.js';
+import { DEFAULT_PERSONAS } from '../runDefaults.js';
 
 export async function hostedQuote(flags = {}, deps = {}) {
   const context = deps.context || await createContext({ apiUrl: flags.apiUrl, repoRoot: flags.repoRoot, requireAuth: true });
@@ -11,7 +15,7 @@ export async function hostedQuote(flags = {}, deps = {}) {
     const result = await quoteHostedRun({ api: context.api, apiUrl: context.api.apiUrl,
       gameId: resolveGameId(flags, context.config), buildId: flags.build, profileVersion: flags.profile,
       persona: flags.persona, standardProvider: flags.standardProvider, includeVideo: Boolean(flags.video),
-      includeTranscript: Boolean(flags.transcript), output: flags.output });
+      output: flags.output });
     if (flags.json) ui.json(result);
     else {
       hostedQuoteLines(result).forEach(line => ui.info(line));
@@ -37,3 +41,141 @@ export async function hostedRun(filename, flags = {}, deps = {}) {
     return result.state === 'declined' ? ExitCode.CANCELED : ExitCode.OK;
   });
 }
+
+const POLL_MS = 15000;
+const dollars = cents => `$${(cents / 100).toFixed(2)}`;
+const sleepFor = ms => new Promise(resolve => { const timer = setTimeout(resolve, ms); if (timer.unref) timer.unref(); });
+
+/** One status object for --json and for the printed lines. */
+function statusView(gameId, apiUrl, { admission, job, runs }, now = Date.now()) {
+  const status = hostedPlaytestStatus(admission, job, runs, now);
+  return {
+    admissionId: admission.admissionId,
+    jobId: admission.jobId || null,
+    gameId,
+    buildId: admission.buildId || null,
+    phase: status.phase,
+    label: status.label,
+    detail: status.detail,
+    terminal: status.terminal,
+    settled: status.settled,
+    cancelRequested: status.cancelRequested,
+    failure: status.failure || null,
+    elapsedSeconds: status.elapsedSeconds,
+    totalPriceCents: Number.isSafeInteger(admission.totalPriceCents) ? admission.totalPriceCents : null,
+    modes: modeOutcomes(runs, Array.isArray(admission.controllers) ? admission.controllers : ['standard', 'jev']),
+    summaryReport: job?.summary_report ?? null,
+    reportUrl: admission.jobId ? jobLink(gameId, admission.jobId, apiUrl) : null
+  };
+}
+
+function printOutcome(view) {
+  ui.info(`${view.label}. ${view.detail}`);
+  if (view.failure) ui.info(`Reason: ${view.failure}`);
+  if (view.cancelRequested && view.phase !== 'canceled') ui.info('Cancellation was requested.');
+  if (TERMINAL_PHASES.includes(view.phase) || view.modes.some(row => row.state !== 'not_started')) view.modes.forEach(row => ui.info(modeLine(row)));
+  if (TERMINAL_PHASES.includes(view.phase) && !view.settled) ui.info('Refunds and cleanup are still settling.');
+  if (view.reportUrl) ui.info(`Report: ${view.reportUrl}`);
+}
+
+const exitFor = view => view.phase === 'canceled' ? ExitCode.CANCELED : view.phase === 'failed' ? ExitCode.FAILURE : ExitCode.OK;
+
+/** Poll until the phase is terminal, printing each phase change once. */
+async function waitForRun({ api, gameId, admissionId, apiUrl, sleep, now, onPhase }) {
+  let last = null;
+  for (;;) {
+    const view = statusView(gameId, apiUrl, await readHostedRun({ api, gameId, admissionId }), now());
+    if (view.phase !== last) { last = view.phase; onPhase(view); }
+    if (TERMINAL_PHASES.includes(view.phase)) return view;
+    await sleep();
+  }
+}
+
+const phaseLine = flags => row => { if (!flags.json) ui.info(`${row.label}: ${row.detail}`); };
+
+/**
+ * `hosted run` with no saved quote: the newest eligible build (or --build), a
+ * fresh quote, the price and consent printed from it, one confirmation, one
+ * admission. The admission keeps the saved-quote path's journal and never retries.
+ */
+export async function hostedRunDirect(flags = {}, deps = {}) {
+  if (flags.json && !flags.yes && !deps.confirm) throw new CliError('A hosted run charges prepaid funds. Use --yes with --json. Nothing was charged.');
+  const context = deps.context || await createContext({ apiUrl: flags.apiUrl, repoRoot: flags.repoRoot, requireAuth: true });
+  const now = deps.now || Date.now, sleep = deps.sleep || (() => sleepFor(POLL_MS));
+  return withAuthHandling(context, async () => {
+    const api = context.api, apiUrl = api.apiUrl, gameId = resolveGameId(flags, context.config);
+    const { offer, build, funding } = await prepareHostedRun({ api, apiUrl, gameId, buildId: flags.build,
+      persona: flags.persona || DEFAULT_PERSONAS[0], includeVideo: Boolean(flags.video), now });
+    if (!flags.json) {
+      ui.info(`Build ${build.buildId}${build.entrypoint ? ` (${build.entrypoint})` : ''}${flags.build ? '' : ', the newest ready build'}.`);
+      hostedQuoteLines(offer).forEach(line => ui.info(line));
+      hostedConsentLines(offer).forEach(line => ui.info(line));
+    }
+    const short = fundingShortfall(offer.quote, funding);
+    if (short) {
+      const topUp = short.requiredTopUpCents ? ` Add at least ${dollars(short.requiredTopUpCents)} of prepaid funds, then run this again.` : ' Add prepaid funds, then run this again.';
+      throw new CliError(`The balance does not meet this hosted run's funding requirement. Nothing was charged.${topUp}`, ExitCode.ENVIRONMENT);
+    }
+    const confirm = deps.confirm || (question => ui.confirm(question, { yes: Boolean(flags.yes) }));
+    if (!await confirm(confirmQuestion(offer))) {
+      if (flags.json) ui.json({ state: 'declined', gameId, buildId: build.buildId, walletMutationRequested: false });
+      else ui.info('Declined. Nothing was charged.');
+      return ExitCode.CANCELED;
+    }
+    const admitted = await admitHostedOffer({ offer, api, apiUrl, repoRoot: context.repoRoot, now });
+    const reportUrl = jobLink(gameId, admitted.jobId, apiUrl);
+    const result = { state: admitted.state, admissionId: admitted.admissionId, jobId: admitted.jobId, gameId, buildId: build.buildId,
+      persona: offer.request.personas[0], totalPriceCents: admitted.totalPriceCents, dueNowCents: offer.quote.dueNowCents,
+      journal: admitted.journal, reportUrl };
+    if (!flags.json) {
+      ui.ok(`Paid ${dollars(offer.quote.dueNowCents)}. Hosted run ${admitted.admissionId}, job ${admitted.jobId}.`);
+      ui.info(`Check on it with: ravensight-playtest hosted status ${admitted.admissionId}`);
+    }
+    if (!flags.wait) {
+      if (flags.json) ui.json(result);
+      else ui.info(`Report: ${reportUrl}`);
+      return ExitCode.OK;
+    }
+    const view = await waitForRun({ api, gameId, admissionId: admitted.admissionId, apiUrl, sleep, now, onPhase: phaseLine(flags) });
+    if (flags.json) ui.json({ ...result, status: view });
+    else printOutcome(view);
+    return exitFor(view);
+  });
+}
+
+export async function hostedStatus(admissionId, flags = {}, deps = {}) {
+  const context = deps.context || await createContext({ apiUrl: flags.apiUrl, repoRoot: flags.repoRoot, requireAuth: true });
+  const now = deps.now || Date.now, sleep = deps.sleep || (() => sleepFor(POLL_MS));
+  return withAuthHandling(context, async () => {
+    const api = context.api, apiUrl = api.apiUrl, gameId = resolveGameId(flags, context.config);
+    const view = flags.wait
+      ? await waitForRun({ api, gameId, admissionId, apiUrl, sleep, now, onPhase: phaseLine(flags) })
+      : statusView(gameId, apiUrl, await readHostedRun({ api, gameId, admissionId }), now());
+    if (flags.json) ui.json(view); else printOutcome(view);
+    return flags.wait ? exitFor(view) : ExitCode.OK;
+  });
+}
+
+export async function hostedCancel(admissionId, flags = {}, deps = {}) {
+  if (flags.json && !flags.yes && !deps.confirm) throw new CliError('Use --yes with --json to cancel a hosted run. Nothing was canceled.');
+  const context = deps.context || await createContext({ apiUrl: flags.apiUrl, repoRoot: flags.repoRoot, requireAuth: true });
+  const now = deps.now || Date.now;
+  return withAuthHandling(context, async () => {
+    const api = context.api, apiUrl = api.apiUrl, gameId = resolveGameId(flags, context.config);
+    const confirm = deps.confirm || (question => ui.confirm(question, { yes: Boolean(flags.yes),
+      noTerminalMessage: 'No terminal to confirm in: pass --yes to cancel this run.' }));
+    if (!await confirm(`Cancel hosted run ${admissionId}? Work already completed follows the accepted policy; unstarted work is refunded during settlement.`)) {
+      if (flags.json) ui.json({ state: 'kept', admissionId });
+      else ui.info('Nothing was canceled.');
+      return ExitCode.CANCELED;
+    }
+    await cancelHostedRun({ api, gameId, admissionId });
+    const view = statusView(gameId, apiUrl, await readHostedRun({ api, gameId, admissionId }), now());
+    if (flags.json) ui.json(view);
+    else {
+      ui.ok(view.phase === 'canceled' ? `Hosted run ${admissionId} is canceled.` : `Cancellation requested for hosted run ${admissionId}.`);
+      printOutcome(view);
+    }
+    return ExitCode.OK;
+  });
+}

package/src/commands/profile.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
 import { optionsFrom, unknownOptionNotes } from '../run/args.js';
 import { settleFailureLine } from '../run/settle.js';
+import { failureReason } from '../run/failureReason.js';
 import { getDeps } from '../run/deps.js';
 import EXIT from '../run/exit.js';
 import { createHeartbeat } from '../run/heartbeat.js';
@@ -234,7 +235,7 @@ async function safeFail({ api, gameId, jobId, runId, error, log }) {
   try {
     await api.runs.complete(gameId, jobId, runId, {
       state: 'failed',
-      reason: String(error && error.message).slice(0, 400),
+      reason: failureReason(error, { fallback: 'the profile stopped on an error' }),
       quit_reason: 'error'
     });
   } catch (completeError) {