ravensight-playtest 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ravensight-playtest",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Local AI playtests and seeded game simulations with reports in Ravensight.",
   "license": "MIT",
   "homepage": "https://ravensight.io/docs/#playtest",

package/src/commands/run.js

@@ -870,11 +870,11 @@ export async function deliver({ deps, api, gameId, jobId, runId, directory, outc
         body
       });
     } catch (error) {
-      // A server older than partial reports refuses one as `invalid_report`.
-      // The uploads are already done by then, so the run is completed
-      // without it rather than left open: the notes stay on disk in
-      // report.json either way.
-      if (!(body.report && body.report.partial && error && error.status === 422 && error.code === 'invalid_report')) throw error;
+      // A server older than partial reports refuses one as `invalid_report`,
+      // and any server refuses one with a secret shaped value in it. The
+      // uploads are already done by then, so the run is completed without it
+      // rather than left open: the notes stay on disk in report.json either way.
+      if (!(body.report && body.report.partial && error && error.status === 422 && ['invalid_report', 'secrets_detected'].includes(error.code))) throw error;
       log(`run ${runId}: the server refused the partial report (${String(error.message)}), so the run is completed without it. The notes are in ${directory}.`);
       if (delivery) delivery.reportRefused = true;
       const { report: ignored, report_md: alsoIgnored, ...withoutReport } = body;
@@ -1037,7 +1037,10 @@ async function aggregatePhase({
 
   // The aggregate reads reports off disk, so a resumed job whose earlier runs
   // were played by a previous process is covered too.
-  const reports = await loadRunReports(repoRoot, jobId, personaRuns, journal);
+  // A failed run's report explains the failure and its unit is refunded. It is
+  // not a result to summarise, and the server refuses a summary of only those.
+  const reports = (await loadRunReports(repoRoot, jobId, personaRuns, journal))
+    .map(run => (run.state === 'failed' ? { ...run, report: null } : run));
   let aggregate;
   try {
     aggregate = await buildAggregate({

package/src/run/drivers/stdio.js

@@ -18,7 +18,7 @@ export async function readBridgeConfig(file) {
 }
 
 export function createStdioDriver({ spawn: spawnImpl = spawn, timeoutMs = 30000 } = {}) {
-  let child, buffer = '', nextId = 0, runDirectory, step = 0, shots = 0, lastHash;
+  let child, childState, buffer = '', nextId = 0, runDirectory, step = 0, shots = 0, lastHash;
   const pending = new Map();
   const fail = message => {
     for (const entry of pending.values()) { clearTimeout(entry.timer); entry.reject(new DriverError(message, { fatal: true })); }
@@ -52,6 +52,9 @@ export function createStdioDriver({ spawn: spawnImpl = spawn, timeoutMs = 30000
       const config = await readBridgeConfig(target);
       runDirectory = runDir;
       child = spawnImpl(config.command, config.args || [], { cwd: config.cwd || path.dirname(path.resolve(target)), shell: false, stdio: ['pipe', 'pipe', 'pipe'] });
+      const state = { process: child, closed: false, stopping: null };
+      state.close = new Promise(resolve => child.once('close', () => { state.closed = true; resolve(); }));
+      childState = state;
       child.stdout.setEncoding('utf8');
       child.stdout.on('data', chunk => {
         buffer += chunk;
@@ -92,20 +95,33 @@ export function createStdioDriver({ spawn: spawnImpl = spawn, timeoutMs = 30000
     async screenshot(reason) {
       const image = await request('screenshot');
       if (typeof image?.pngBase64 !== 'string' || !image.pngBase64.startsWith('iVBORw0KGgo')) throw new DriverError('This bridge did not return a PNG screenshot.');
-      const relativePath = path.join('screenshots', screenshotName(++shots, reason));
+      const relativePath = path.posix.join('screenshots', screenshotName(++shots, reason));
       const file = path.join(runDirectory, relativePath);
       await fs.writeFile(file, Buffer.from(image.pngBase64, 'base64'));
       return { path: file, relativePath };
     },
     async consoleErrors() { return []; },
     async stop() {
-      if (child && child.exitCode === null && !child.killed) {
-        child.kill('SIGTERM');
-        const process = child;
-        const timer = setTimeout(() => { if (process.exitCode === null) process.kill('SIGKILL'); }, 1000);
-        timer.unref();
-      }
       fail('Game bridge stopped.');
+      const state = childState;
+      if (state && !state.stopping) {
+        state.stopping = (async () => {
+          if (state.closed) return;
+          const process = state.process;
+          let deadline;
+          const force = setTimeout(() => { if (!state.closed) process.kill('SIGKILL'); }, 1000);
+          try {
+            const timedOut = new Promise((resolve, reject) => {
+              deadline = setTimeout(() => reject(new DriverError('Game bridge did not close after stopping.', { fatal: true })), 5000);
+            });
+            if (process.exitCode === null && process.signalCode === null && !process.killed) process.kill('SIGTERM');
+            // Windows can retain the bridge's cwd until its pipes close, even
+            // after exit. Concurrent/repeated stops share the same close wait.
+            await Promise.race([state.close, timedOut]);
+          } finally { clearTimeout(force); clearTimeout(deadline); }
+        })();
+      }
+      if (state) await state.stopping;
       return { videoPath: null };
     }
   };

package/src/run/drivers/web.js

@@ -1706,7 +1706,9 @@ export function createWebDriver({ importer, headless = true, playtest = null, pl
     async screenshot(name) {
       const current = requirePage();
       shots += 1;
-      const relativePath = path.join('screenshots', screenshotName(shots, name));
+      // Forward slashes on every platform: this is the evidence ref the server
+      // matches against upload paths.
+      const relativePath = path.posix.join('screenshots', screenshotName(shots, name));
       const absolute = path.join(runDirectory, relativePath);
       await mkdir(path.dirname(absolute), { recursive: true });
       await current.screenshot({ path: absolute, type: 'png', timeout: ACTION_TIMEOUT_MS });

package/src/run/drivers/webdriver.js

@@ -61,7 +61,7 @@ export function createWebDriverAdapter({name='desktop_driver',fetch:fetchImpl=gl
    }catch(error){return {ok:false,changed:false,error:error instanceof DriverError?error.message:'Device input failed.'};}
    finally {if(session)await request('DELETE',route('/actions')).catch(()=>{});}
   },
-  async screenshot(reason){const relativePath=path.join('screenshots',screenshotName(++shots,reason));const file=path.join(runDirectory,relativePath);await fs.writeFile(file,Buffer.from(await frame(),'base64'));return {path:file,relativePath,reason};},
+  async screenshot(reason){const relativePath=path.posix.join('screenshots',screenshotName(++shots,reason));const file=path.join(runDirectory,relativePath);await fs.writeFile(file,Buffer.from(await frame(),'base64'));return {path:file,relativePath,reason};},
   async consoleErrors(){return [];},
   async stop(){if(session){const current=route('');session=null;await request('DELETE',current);}return {videoPath:null};}
  };return driver;

package/src/run/personaLoop.js

@@ -7,7 +7,7 @@ import { withRollingCacheBreakpoint } from './fixLoop.js';
 import { callStepWithRetry, ProxyError, STEPS } from './model.js';
 import { RUN_FILES } from './paths.js';
 import { appendNormalisedMarkdown, checkEvidence, createReportValidator, lintMarkdownSections, normaliseEnums, normaliseEvidence, repairInstruction, REQUIRED_MARKDOWN_SECTIONS, stampReport, writeReportFiles } from './report.js';
-import { assertNoSecrets } from './secretScan.js';
+import { assertNoSecrets, scanForSecrets } from './secretScan.js';
 import { ACTION_TOOLS, PLAY_TOOLS, SWIPE_TOOL, REPORT_TOOLS, executeTool } from './tools.js';
 import { createTranscript } from './transcript.js';
 import { createUsageLedger, writeUsageFile } from './usage.js';
@@ -35,14 +35,17 @@ import { MIN_PASSWORD_CHARS } from '../briefLocal.js';
  * - `X-Playtest-Budget: warn` at 80 percent of the run budget starts a wrap
  *   up, so the report (which is the product) gets written while there is
  *   still budget to write it with.
- * - A 402 means the money is gone. Nothing further is asked of the model,
- *   including the report: a partial `report.md` and `report.json` are
- *   written locally from the notes (`partial: true`, each note an
+ * - An act 402 stops gameplay. If its authoritative figures show room, the
+ *   cheaper report phase may still fit. Otherwise partial `report.md` and
+ *   `report.json` files are written locally from the notes (`partial: true`, each note an
  *   unreviewed finding), `complete` is sent with `state: budget_exceeded`
  *   and that report, and the process exits 2. The notes are the one thing
  *   the run bought before the money ran out, so they are not thrown away.
  */
 
+/** Why a report is partial when the money ran out. */
+const BUDGET_PARTIAL_REASON = 'The run reached its model budget before the report could be completed. What the persona saw is below, and report.json carries the notes as unreviewed findings.';
+
 /**
  * Order across notes and screenshots, so a partial report can attach the
  * screenshot nearest to each note. Module wide and only ever compared within
@@ -161,6 +164,9 @@ export async function runPersona(args) {
   // what the screen looked like next and a finding can cite where a failure
   // is visible.
   const observations = [];
+  // What the persona did, kept out here so a report can still say so when the
+  // play loop dies part way through.
+  const actionRecords = [];
   let imageBudget = maxImages;
 
   await mkdir(path.join(runDirectory, 'screenshots'), { recursive: true });
@@ -221,6 +227,7 @@ export async function runPersona(args) {
       notes,
       screenshots,
       observations,
+      actionRecords,
       imageBudget,
       keepObservations,
       onImageBudget: next => {
@@ -241,20 +248,12 @@ export async function runPersona(args) {
       return finish(outcome, ledger, runDirectory, transcript, heartbeat);
     }
 
-    if (play.budgetExceeded) {
+    if (play.budgetExceeded && !play.reportBudgetAvailable) {
       outcome.state = 'budget_exceeded';
       outcome.quitReason = 'cost_cap';
-      // Nothing more is asked of the model: there is no budget left to ask
-      // with, and a refused call would just be another 402.
-      // A report that cannot be written (a secret shaped note, a full disk)
-      // must not turn an out of budget run into a failed one.
-      try {
-        await writePartialReport({ outcome, runDirectory, persona, driverName, target, notes, screenshots, play, skill, ledger, runId, jobId, startedAt, endedAt });
-      } catch (writeError) {
-        outcome.report = null;
-        outcome.reportMarkdown = null;
-        log(`the partial report could not be written: ${String(writeError && writeError.message)}`);
-      }
+      // No positive remaining budget was established by the refusal.
+      // Preserve the notes without authorizing another model call.
+      await writeSomeReport({ outcome, runDirectory, persona, driverName, target, notes, screenshots, actionRecords, play, skill, ledger, runId, jobId, startedAt, endedAt, log });
       return finish(outcome, ledger, runDirectory, transcript, heartbeat);
     }
 
@@ -290,8 +289,8 @@ export async function runPersona(args) {
     outcome.report = written.report;
     outcome.reportMarkdown = written.markdown;
     outcome.reportLint = written.lint;
-    outcome.state = 'succeeded';
-    outcome.quitReason = written.report.quit_reason;
+    outcome.state = play.budgetExceeded ? 'budget_exceeded' : 'succeeded';
+    outcome.quitReason = play.budgetExceeded ? 'cost_cap' : written.report.quit_reason;
     outcome.quitDetail = written.report.quit_detail || '';
     return finish(outcome, ledger, runDirectory, transcript, heartbeat);
   } catch (error) {
@@ -301,20 +300,37 @@ export async function runPersona(args) {
       outcome.quitReason = 'cost_cap';
       // The money ran out in the report step itself: the notes are still
       // worth keeping, by the same rule as a 402 during play.
-      try {
-        const play = { actionsTaken: outcome.actionsTaken, quitReason: 'cost_cap', quitDetail: String(error.message || '') };
-        await writePartialReport({ outcome, runDirectory, persona, driverName, target, notes, screenshots, play, skill, ledger, runId, jobId, startedAt, endedAt: new Date().toISOString() });
-      } catch (writeError) {
-        log(`the partial report could not be written: ${String(writeError && writeError.message)}`);
-      }
+      const play = { actionsTaken: outcome.actionsTaken, quitReason: 'cost_cap', quitDetail: String(error.message || '') };
+      await writeSomeReport({ outcome, runDirectory, persona, driverName, target, notes, screenshots, actionRecords, play, skill, ledger, runId, jobId, startedAt, endedAt: new Date().toISOString(), log, preservedMarkdown: error.completedReportMarkdown });
     } else if (error instanceof ProxyError && error.isClosed) {
       outcome.state = 'canceled';
       outcome.quitReason = 'error';
     } else {
       outcome.state = 'failed';
       outcome.quitReason = 'error';
+      // A run that broke still reports what it saw and why it stopped. The
+      // state is still `failed`, so the unit is still refunded; the report
+      // costs no model call. An abort is the person stopping it, not a failure.
+      if (!args.signal?.aborted) {
+        const detail = safeErrorDetail(error, localBrief);
+        // The play loop's count only reaches `outcome` when it returns, and this
+        // may be the play loop dying.
+        const actionsTaken = Math.max(outcome.actionsTaken || 0, actionLogFrom(actionRecords).length);
+        const play = { actionsTaken, quitReason: 'error', quitDetail: detail };
+        await writeSomeReport({
+          outcome, runDirectory, persona, driverName, target, notes, screenshots, actionRecords, play, skill, ledger, runId, jobId, startedAt, endedAt: new Date().toISOString(), log,
+          quitReason: 'error',
+          // The notes stay in report.md and out of report.json. Nothing reviewed
+          // them, they may be symptoms of the crash, and what report.json holds
+          // becomes findings, analyst memory and graph nodes on the server.
+          findings: [],
+          reason: `The run stopped on an error before its report was written: ${detail}`,
+          bareReason: 'The run stopped on an error before its report was written.'
+        });
+      }
     }
-    outcome.quitDetail = String(error && error.message ? error.message : error);
+    // Sent to the server as the run's reason, so it is as safe as the report.
+    outcome.quitDetail = safeErrorDetail(error, localBrief);
     transcript.write({ kind: 'error', message: outcome.quitDetail });
     await finish(outcome, ledger, runDirectory, transcript, heartbeat);
     throw Object.assign(error, { outcome });
@@ -327,6 +343,9 @@ export async function runPersona(args) {
  * @returns {Promise<Object>}
  */
 async function playLoop({
+  // The observation and action lines of the transcript, kept for the report
+  // step's "Actions you took" list and for a partial report.
+  actionRecords = [],
   api,
   controller = 'standard',
   signal: argsSignal,
@@ -375,9 +394,6 @@ async function playLoop({
     }
   })) : availableTools;
   const recentActions = [];
-  // The observation and action lines of the transcript, kept for the report
-  // step's "Actions you took" list.
-  const actionRecords = [];
   let latestObservation = '';
   let visualObservation = false;
   const messages = [];
@@ -387,6 +403,7 @@ async function playLoop({
   let quitDetail = '';
   let budgetWarned = false;
   let budgetExceeded = false;
+  let reportBudgetAvailable = false;
   let canceled = false;
   let unchanged = 0;
   const maxTurns = maxActions * 3 + 20;
@@ -458,6 +475,7 @@ async function playLoop({
     } catch (error) {
       if (error instanceof ProxyError && error.isBudget) {
         budgetExceeded = true;
+        reportBudgetAvailable = hasPositiveRemainingBudget(error);
         quitReason = 'cost_cap';
         quitDetail = error.message;
         break;
@@ -666,6 +684,7 @@ async function playLoop({
     quitDetail,
     budgetWarned,
     budgetExceeded,
+    reportBudgetAvailable,
     canceled,
     imageBudget,
     finalScreenshot: final ? final.relativePath : null,
@@ -779,7 +798,7 @@ async function reportPhase({
   // never escalates to a dearer tier after a warning, and a 402 on a report
   // turn gets one retry with the output ceiling cut to what the refusal says
   // still fits.
-  const escalate = shouldEscalate(persona) && !play.budgetWarned;
+  const escalate = shouldEscalate(persona) && !play.budgetWarned && !play.budgetExceeded;
   let maxTokens = REPORT_MAX_TOKENS;
   let shrunk = false;
   let lastCandidate = null;
@@ -821,6 +840,14 @@ async function reportPhase({
         log(`the model budget ran out on a follow-up report turn; keeping the report.json already written (${lint.length} problem(s)).`);
         break;
       }
+      // A completed markdown write can survive a cut-off JSON write. Keep
+      // that draft without promoting its prose into structured findings.
+      if (typeof markdown === 'string' && markdown.trim()) {
+        const safeMarkdown = scrubSecrets(markdown, secrets);
+        if (Buffer.byteLength(safeMarkdown, 'utf8') <= 256 * 1024 && scanForSecrets(safeMarkdown).length === 0) {
+          error.completedReportMarkdown = safeMarkdown;
+        }
+      }
       throw error;
     }
     ledger.record({ model: answer.model, usage: answer.usage, ms: Date.now() - askedAt });
@@ -875,7 +902,10 @@ async function reportPhase({
     if (enumFixed.changes.length > 0) {
       transcript.write({ kind: 'report_values_normalised', attempt, changes: enumFixed.changes.map(change => ({ id: change.id, field: change.field, from: change.from, to: change.to })) });
     }
-    const capped = normalised ? capNetworkOnlyFindings(stampReport(enumFixed.report, facts), { notes, screenshots }) : null;
+    const reportCandidate = play.budgetExceeded
+      ? { ...enumFixed.report, partial: true, quit_reason: 'cost_cap', quit_detail: play.quitDetail }
+      : enumFixed.report;
+    const capped = normalised ? capNetworkOnlyFindings(stampReport(reportCandidate, facts), { notes, screenshots }) : null;
     const runnerDrop = capped ? dropRunnerRejectedFindings(capped, { notes, observations }) : { report: null, dropped: [] };
     for (const entry of runnerDrop.dropped) {
       transcript.write({ kind: 'finding_dropped', id: entry.finding.id, severity: entry.finding.severity, title: entry.finding.title, reason: entry.reason });
@@ -953,7 +983,7 @@ async function reportPhase({
   // after the report is settled, so a refusal can cost the check and never
   // the report.
   report = scrubSecrets(report, secrets);
-  if (!shrunk) {
+  if (!shrunk && !play.budgetExceeded) {
     const checked = await checkClaimsAgainstScreenshots({ client, jobId, runId, report, screenshots, runDirectory, ledger, transcript, log });
     if (checked.downgraded.length > 0) {
       report = checked.report;
@@ -961,7 +991,7 @@ async function reportPhase({
       log(`downgraded ${checked.downgraded.length} finding(s) their own screenshot contradicts: ${checked.downgraded.map(entry => `${entry.id} (${entry.from} to ${entry.to}, ${entry.screenshot})`).join(', ')}`);
     }
   } else {
-    transcript.write({ kind: 'claim_check_skipped', reason: 'the report turn needed a smaller output ceiling to fit the budget' });
+    transcript.write({ kind: 'claim_check_skipped', reason: play.budgetExceeded ? 'gameplay stopped for budget; preserving the report budget' : 'the report turn needed a smaller output ceiling to fit the budget' });
   }
 
   if (!markdown) {
@@ -1122,6 +1152,13 @@ export async function checkClaimsAgainstScreenshots({ client, jobId, runId, repo
 /** The smallest output ceiling worth retrying a report turn with. */
 export const REPORT_MIN_TOKENS = 1536;
 
+/** A refused act is not proof that a smaller, cheaper report cannot fit. */
+function hasPositiveRemainingBudget(error) {
+  const { usd_used: used, usd_max: maximum, projected_usd: projected } = error.figures || {};
+  return [used, maximum, projected].every(value => typeof value === 'number' && Number.isFinite(value))
+    && used >= 0 && maximum > used && projected > maximum - used;
+}
+
 /** Whether a 402 carried the three figures a retry is sized from. */
 export function hasBudgetFigures(error) {
   const figures = (error && error.figures) || {};
@@ -1490,7 +1527,7 @@ async function finish(outcome, ledger, runDirectory, transcript, heartbeat) {
  * screenshot list and says plainly that it is partial, rather than
  * inventing a persona verdict nobody gave.
  */
-export function renderFallbackMarkdown({ persona, driverName, target, notes, screenshots, play, reason }) {
+export function renderFallbackMarkdown({ persona, driverName, target, notes, screenshots, actions = [], play, reason }) {
   const good = notes.filter(note => note.kind === 'good');
   const bad = notes.filter(note => note.kind === 'bug' || note.kind === 'confusing');
   const network = notes.filter(note => note.automatic && note.url);
@@ -1509,6 +1546,7 @@ export function renderFallbackMarkdown({ persona, driverName, target, notes, scr
     '## Why this report is partial',
     reason,
     '',
+    ...(actions.length > 0 ? ['## What the persona did', actionLogLines(actions), ''] : []),
     '## What worked',
     list(good),
     '',
@@ -1582,7 +1620,7 @@ export function notesToFindings(notes, screenshots) {
       description: text,
       repro_steps: [`Seen after ${Number(note.at_action) || 0} action(s) in this run.`],
       evidence: shot
-        ? [{ type: 'screenshot', ref: shot.relativePath }]
+        ? [{ type: 'screenshot', ref: String(shot.relativePath).replace(/\\/g, '/') }]
         : [{ type: 'transcript_step', ref: `action ${Number(note.at_action) || 0}` }]
     });
   }
@@ -1596,9 +1634,9 @@ export function notesToFindings(notes, screenshots) {
  * and no persona verdict was recorded; `partial` is what tells a reader not
  * to read them as one.
  */
-async function writePartialReport({ outcome, runDirectory, persona, driverName, target, notes, screenshots, play, skill, ledger, runId, jobId, startedAt, endedAt }) {
+async function writePartialReport({ outcome, runDirectory, persona, driverName, target, notes, screenshots, actionRecords = [], play, skill, ledger, runId, jobId, startedAt, endedAt, quitReason = 'cost_cap', reason = BUDGET_PARTIAL_REASON, findings = null, preservedMarkdown = null }) {
   const report = stampReport({
-    findings: notesToFindings(notes, screenshots),
+    findings: findings || notesToFindings(notes, screenshots),
     sentiment: { fun: 3, clarity: 3, frustration: 3 },
     would_continue: false,
     partial: true
@@ -1613,24 +1651,70 @@ async function writePartialReport({ outcome, runDirectory, persona, driverName,
     actionsTaken: play.actionsTaken,
     usage: ledger.toReportUsage(),
     promptVersion: promptVersionOf(skill) || 'unknown',
-    quitReason: 'cost_cap',
+    quitReason,
     quitDetail: play.quitDetail
   });
-  const markdown = renderFallbackMarkdown({
+  const fallbackMarkdown = renderFallbackMarkdown({
     persona,
     driverName,
     target,
     notes,
     screenshots,
+    actions: actionLogFrom(actionRecords),
     play,
-    reason: 'The run reached its model budget before the report step. What the persona saw is below, and report.json carries the notes as unreviewed findings.'
+    reason
   });
+  const markdown = preservedMarkdown
+    ? ['# Playtest (partial report draft)', '',
+      'The run reached its model budget before this draft could be completed and checked. It is preserved below for review.',
+      '', preservedMarkdown, '', '---', '', fallbackMarkdown].join('\n')
+    : fallbackMarkdown;
   const stamped = stampGeneratedAt(markdown, new Date().toISOString(), reportFacts({ persona, driverName, target, play }));
   await writeReportFiles({ runDirectory, markdown: stamped, report });
   outcome.report = report;
   outcome.reportMarkdown = stamped;
 }
 
+/**
+ * An error message fit to leave this machine: the brief's own secrets replaced,
+ * and the whole message withheld if anything else in it is shaped like a secret.
+ */
+function safeErrorDetail(error, localBrief) {
+  const text = scrubSecrets(String(error && error.message ? error.message : error), secretsOf(localBrief));
+  if (scanForSecrets(text).length > 0) return 'The error message was withheld because it contained something shaped like a secret.';
+  return text.slice(0, 400);
+}
+
+/**
+ * A run always ends with a report. If the notes cannot be written (a secret
+ * shaped note, a secret in an error message), the report goes out without them
+ * and says so: the reason and the action count are worth more than nothing.
+ * Only a failure of the disk itself leaves no report.
+ */
+async function writeSomeReport({ log, bareReason = BUDGET_PARTIAL_REASON, ...report }) {
+  try {
+    await writePartialReport(report);
+    return;
+  } catch (error) {
+    log(`the partial report could not be written with its notes: ${String(error && error.message)}`);
+  }
+  try {
+    await writePartialReport({
+      ...report,
+      preservedMarkdown: null,
+      notes: [],
+      screenshots: [],
+      actionRecords: [],
+      play: { ...report.play, quitDetail: '' },
+      reason: `${bareReason} The notes were left out of this report because they could not be written safely.`
+    });
+  } catch (error) {
+    report.outcome.report = null;
+    report.outcome.reportMarkdown = null;
+    log(`the partial report could not be written: ${String(error && error.message)}`);
+  }
+}
+
 async function writePartialMarkdown({ runDirectory, persona, driverName, target, notes, screenshots, play, reason }) {
   const markdown = stampGeneratedAt(renderFallbackMarkdown({ persona, driverName, target, notes, screenshots, play, reason }), new Date().toISOString(), reportFacts({ persona, driverName, target, play }));
   assertNoSecrets('report.md', markdown);