audrey 1.0.0 → 1.0.2

package/scripts/publish-release-github-api.mjs

@@ -27,11 +27,14 @@ function parseArgs(argv = process.argv.slice(2)) {
 
   for (let i = 0; i < argv.length; i++) {
     const token = argv[i];
-    if ((token === '--repository' || token === '--repo') && argv[i + 1]) args.repository = argv[++i];
+    if ((token === '--repository' || token === '--repo') && argv[i + 1])
+      args.repository = argv[++i];
     else if (token === '--branch' && argv[i + 1]) args.branch = argv[++i];
-    else if ((token === '--version' || token === '--target-version') && argv[i + 1]) args.version = argv[++i];
+    else if ((token === '--version' || token === '--target-version') && argv[i + 1])
+      args.version = argv[++i];
     else if (token === '--token-env' && argv[i + 1]) args.tokenEnv = argv[++i];
-    else if (token === '--concurrency' && argv[i + 1]) args.concurrency = Number.parseInt(argv[++i], 10);
+    else if (token === '--concurrency' && argv[i + 1])
+      args.concurrency = Number.parseInt(argv[++i], 10);
     else if (token === '--apply') args.apply = true;
     else if (token === '--json') args.json = true;
     else if (token === '--force') args.force = true;
@@ -84,7 +87,10 @@ function run(command, args, options = {}) {
 }
 
 function assertOk(result) {
-  if (!result.ok) throw new Error(`${result.command} failed: ${result.stderr || result.stdout || result.error || result.status}`);
+  if (!result.ok)
+    throw new Error(
+      `${result.command} failed: ${result.stderr || result.stdout || result.error || result.status}`,
+    );
   return result.stdout;
 }
 
@@ -97,7 +103,9 @@ function normalized(path) {
 }
 
 function sha256(path) {
-  return createHash('sha256').update(readFileSync(resolve(ROOT, path))).digest('hex');
+  return createHash('sha256')
+    .update(readFileSync(resolve(ROOT, path)))
+    .digest('hex');
 }
 
 function readJsonIfExists(path) {
@@ -106,9 +114,24 @@ function readJsonIfExists(path) {
 }
 
 function collectChangedPaths() {
-  const changed = splitZ(assertOk(run('git', ['-c', 'core.quotepath=false', 'diff', '--name-only', '-z', 'HEAD', '--'])));
-  const untracked = splitZ(assertOk(run('git', ['-c', 'core.quotepath=false', 'ls-files', '--others', '--exclude-standard', '-z'])));
-  return [...new Set([...changed, ...untracked].map(normalized))].sort((a, b) => a.localeCompare(b));
+  const changed = splitZ(
+    assertOk(run('git', ['-c', 'core.quotepath=false', 'diff', '--name-only', '-z', 'HEAD', '--'])),
+  );
+  const untracked = splitZ(
+    assertOk(
+      run('git', [
+        '-c',
+        'core.quotepath=false',
+        'ls-files',
+        '--others',
+        '--exclude-standard',
+        '-z',
+      ]),
+    ),
+  );
+  return [...new Set([...changed, ...untracked].map(normalized))].sort((a, b) =>
+    a.localeCompare(b),
+  );
 }
 
 function fileMode(path) {
@@ -136,9 +159,34 @@ function changedEntries() {
 }
 
 function remoteRefs(repository, branch, version) {
-  let result = run('git', ['ls-remote', `https://github.com/${repository}.git`, `refs/heads/${branch}`, `refs/tags/v${version}`], { timeout: 60_000 });
-  if (!result.ok && /schannel|AcquireCredentialsHandle|SEC_E_NO_CREDENTIALS/i.test(`${result.stderr}\n${result.stdout}`)) {
-    result = run('git', ['-c', 'http.sslBackend=openssl', 'ls-remote', `https://github.com/${repository}.git`, `refs/heads/${branch}`, `refs/tags/v${version}`], { timeout: 60_000 });
+  let result = run(
+    'git',
+    [
+      'ls-remote',
+      `https://github.com/${repository}.git`,
+      `refs/heads/${branch}`,
+      `refs/tags/v${version}`,
+    ],
+    { timeout: 60_000 },
+  );
+  if (
+    !result.ok &&
+    /schannel|AcquireCredentialsHandle|SEC_E_NO_CREDENTIALS/i.test(
+      `${result.stderr}\n${result.stdout}`,
+    )
+  ) {
+    result = run(
+      'git',
+      [
+        '-c',
+        'http.sslBackend=openssl',
+        'ls-remote',
+        `https://github.com/${repository}.git`,
+        `refs/heads/${branch}`,
+        `refs/tags/v${version}`,
+      ],
+      { timeout: 60_000 },
+    );
     result.fallback = 'openssl';
   }
 
@@ -155,7 +203,10 @@ function remoteRefs(repository, branch, version) {
 }
 
 function releaseDates() {
-  const headTime = Number.parseInt(assertOk(run('git', ['show', '-s', '--format=%ct', 'HEAD'])), 10);
+  const headTime = Number.parseInt(
+    assertOk(run('git', ['show', '-s', '--format=%ct', 'HEAD'])),
+    10,
+  );
   const commitEpoch = headTime + 1;
   return {
     commitEpoch,
@@ -191,7 +242,9 @@ async function githubJson(token, repository, path, options = {}) {
   const payload = text ? JSON.parse(text) : null;
   if (!response.ok) {
     const message = payload?.message ?? text.slice(0, 500) ?? response.statusText;
-    throw new Error(`GitHub API ${options.method ?? 'GET'} ${path} failed (${response.status}): ${message}`);
+    throw new Error(
+      `GitHub API ${options.method ?? 'GET'} ${path} failed (${response.status}): ${message}`,
+    );
   }
   return payload;
 }
@@ -238,12 +291,18 @@ function localState(args) {
   const bytes = entries.reduce((total, entry) => total + entry.bytes, 0);
   const blockers = [];
 
-  if (!refs.result.ok) blockers.push(`Remote ref check failed: ${refs.result.stderr || refs.result.stdout || refs.result.error}`);
+  if (!refs.result.ok)
+    blockers.push(
+      `Remote ref check failed: ${refs.result.stderr || refs.result.stdout || refs.result.error}`,
+    );
   if (refs.branch && refs.branch !== localHead && !args.force) {
     blockers.push(`Remote ${args.branch} is ${refs.branch}, but local HEAD is ${localHead}`);
   }
   if (refs.tag) blockers.push(`Remote tag v${args.version} already exists at ${refs.tag}`);
-  if (!objectReport?.commit || !objectReport?.tree) blockers.push('Missing .tmp/release-git-object-report.json; run npm run release:artifacts first');
+  if (!objectReport?.commit || !objectReport?.tree)
+    blockers.push(
+      'Missing .tmp/release-git-object-report.json; run npm run release:artifacts first',
+    );
 
   return {
     localHead,
@@ -283,7 +342,9 @@ async function publishWithGitHubApi(args, state, token) {
   });
 
   if (state.expectedReleaseTree && tree.sha !== state.expectedReleaseTree) {
-    throw new Error(`GitHub release tree ${tree.sha} does not match local source-bundle tree ${state.expectedReleaseTree}`);
+    throw new Error(
+      `GitHub release tree ${tree.sha} does not match local source-bundle tree ${state.expectedReleaseTree}`,
+    );
   }
 
   const dates = releaseDates();
@@ -300,7 +361,9 @@ async function publishWithGitHubApi(args, state, token) {
   });
 
   if (state.expectedReleaseCommit && commit.sha !== state.expectedReleaseCommit) {
-    throw new Error(`GitHub release commit ${commit.sha} does not match local source-bundle commit ${state.expectedReleaseCommit}`);
+    throw new Error(
+      `GitHub release commit ${commit.sha} does not match local source-bundle commit ${state.expectedReleaseCommit}`,
+    );
   }
 
   const branchUpdate = await githubJson(token, args.repository, `/git/refs/heads/${args.branch}`, {
@@ -398,12 +461,12 @@ async function main() {
     })),
     changedEntries: args.includeEntries
       ? state.entries.map(entry => ({
-        path: entry.path,
-        deleted: entry.deleted,
-        mode: entry.mode,
-        bytes: entry.bytes,
-        sha256: entry.sha256,
-      }))
+          path: entry.path,
+          deleted: entry.deleted,
+          mode: entry.mode,
+          bytes: entry.bytes,
+          sha256: entry.sha256,
+        }))
       : undefined,
     finalizeArtifacts: state.finalizeArtifacts,
     blockers: [...state.blockers],
@@ -413,7 +476,9 @@ async function main() {
   if (args.apply) {
     const token = process.env[args.tokenEnv];
     if (!token) {
-      report.blockers.push(`Set ${args.tokenEnv} to a GitHub token with contents:write before applying`);
+      report.blockers.push(
+        `Set ${args.tokenEnv} to a GitHub token with contents:write before applying`,
+      );
     } else if (report.blockers.length === 0) {
       report.publish = await publishWithGitHubApi(args, state, token);
     }

package/scripts/smoke-cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -23,7 +23,25 @@ if (!existsSync(cli)) {
   fail(`missing built CLI at ${cli}; run npm run build first`);
 }
 
-const tempRoot = mkdtempSync(join(tmpdir(), 'audrey-smoke-'));
+function createTempRoot() {
+  const candidates = [process.env.AUDREY_SMOKE_TMPDIR, tmpdir(), join(root, '.tmp')].filter(
+    Boolean,
+  );
+  const failures = [];
+
+  for (const candidate of candidates) {
+    try {
+      mkdirSync(candidate, { recursive: true });
+      return mkdtempSync(join(candidate, 'audrey-smoke-'));
+    } catch (error) {
+      failures.push(`${candidate}: ${error.code ?? error.message}`);
+    }
+  }
+
+  fail(`unable to create smoke temp directory (${failures.join('; ')})`);
+}
+
+const tempRoot = createTempRoot();
 const env = {
   ...process.env,
   AUDREY_DATA_DIR: join(tempRoot, 'store'),
@@ -55,10 +73,12 @@ try {
 
   const doctor = JSON.parse(run('doctor --json', ['doctor', '--json']));
   if (doctor.version !== pkg.version || doctor.ok !== true) {
-    fail(`doctor --json returned unexpected release status: ${JSON.stringify({
-      version: doctor.version,
-      ok: doctor.ok,
-    })}`);
+    fail(
+      `doctor --json returned unexpected release status: ${JSON.stringify({
+        version: doctor.version,
+        ok: doctor.ok,
+      })}`,
+    );
   }
 
   const demo = run('demo', ['demo']);

package/scripts/sync-paper-artifacts.mjs

@@ -106,4 +106,8 @@ for (const [path, updater] of updates) {
   }
 }
 
-console.log(changed.length ? `Synced paper artifacts: ${changed.join(', ')}` : 'Paper artifacts already in sync.');
+console.log(
+  changed.length
+    ? `Synced paper artifacts: ${changed.join(', ')}`
+    : 'Paper artifacts already in sync.',
+);

package/scripts/verify-arxiv-compile.mjs

@@ -37,9 +37,12 @@ function pathForReport(path) {
 }
 
 function commandExists(command) {
-  const result = process.platform === 'win32'
-    ? spawnSync(process.env.ComSpec ?? 'cmd.exe', ['/d', '/c', 'where', command], { encoding: 'utf-8' })
-    : spawnSync('sh', ['-lc', `command -v ${command}`], { encoding: 'utf-8' });
+  const result =
+    process.platform === 'win32'
+      ? spawnSync(process.env.ComSpec ?? 'cmd.exe', ['/d', '/c', 'where', command], {
+          encoding: 'utf-8',
+        })
+      : spawnSync('sh', ['-lc', `command -v ${command}`], { encoding: 'utf-8' });
   return result.status === 0;
 }
 
@@ -47,16 +50,17 @@ function compilerPlan(exists = commandExists) {
   if (exists('tectonic')) {
     return {
       name: 'tectonic',
-      stages: [
-        { command: 'tectonic', args: ['--keep-logs', '--keep-intermediates', MAIN_TEX] },
-      ],
+      stages: [{ command: 'tectonic', args: ['--keep-logs', '--keep-intermediates', MAIN_TEX] }],
     };
   }
   if (exists('latexmk')) {
     return {
       name: 'latexmk',
       stages: [
-        { command: 'latexmk', args: ['-pdf', '-interaction=nonstopmode', '-halt-on-error', MAIN_TEX] },
+        {
+          command: 'latexmk',
+          args: ['-pdf', '-interaction=nonstopmode', '-halt-on-error', MAIN_TEX],
+        },
       ],
     };
   }
@@ -78,7 +82,18 @@ function compilerPlan(exists = commandExists) {
       stages: [
         {
           command: 'uvx',
-          args: ['tecto', '-X', 'compile', '--bundle', '__TECTONIC_BUNDLE_URL__', '--keep-logs', '--keep-intermediates', '--reruns', '2', MAIN_TEX],
+          args: [
+            'tecto',
+            '-X',
+            'compile',
+            '--bundle',
+            '__TECTONIC_BUNDLE_URL__',
+            '--keep-logs',
+            '--keep-intermediates',
+            '--reruns',
+            '2',
+            MAIN_TEX,
+          ],
         },
       ],
     };
@@ -164,7 +179,14 @@ async function startTectonicBundleProxy(bundleUrl = TECTONIC_BUNDLE_URL) {
       if (request.headers.range) headers.range = request.headers.range;
       const upstream = await fetch(remoteUrl, { headers });
       response.statusCode = upstream.status;
-      for (const header of ['accept-ranges', 'content-length', 'content-range', 'content-type', 'etag', 'last-modified']) {
+      for (const header of [
+        'accept-ranges',
+        'content-length',
+        'content-range',
+        'content-type',
+        'etag',
+        'last-modified',
+      ]) {
         const value = upstream.headers.get(header);
         if (value) response.setHeader(header, value);
       }
@@ -196,7 +218,7 @@ async function startTectonicBundleProxy(bundleUrl = TECTONIC_BUNDLE_URL) {
 function stageWithBundle(stage, bundleUrl) {
   return {
     command: stage.command,
-    args: stage.args.map(arg => arg === '__TECTONIC_BUNDLE_URL__' ? bundleUrl : arg),
+    args: stage.args.map(arg => (arg === '__TECTONIC_BUNDLE_URL__' ? bundleUrl : arg)),
   };
 }
 
@@ -210,7 +232,12 @@ function runStage(stage, cwd) {
       child.kill();
       if (!settled) {
         settled = true;
-        resolveRun({ status: 1, signal: 'TIMEOUT', stdout, stderr: `${stderr}\nTimed out after 120000ms`.trim() });
+        resolveRun({
+          status: 1,
+          signal: 'TIMEOUT',
+          stdout,
+          stderr: `${stderr}\nTimed out after 120000ms`.trim(),
+        });
       }
     }, 120000);
 
@@ -297,7 +324,9 @@ export async function verifyArxivCompile(options = {}) {
   const logLines = [];
   try {
     proxy = plan.bundleProxy ? await startTectonicBundleProxy() : null;
-    const stages = proxy ? plan.stages.map(stage => stageWithBundle(stage, proxy.url)) : plan.stages;
+    const stages = proxy
+      ? plan.stages.map(stage => stageWithBundle(stage, proxy.url))
+      : plan.stages;
     for (const stage of stages) {
       logLines.push(`$ ${stage.command} ${stage.args.join(' ')}`);
       const result = await runStage(stage, outDir);
@@ -344,7 +373,7 @@ export function verifyArxivCompileReport(options = {}) {
   const allowPending = options.allowPending !== false;
   const failures = [];
   const blockers = [];
-  let report = null;
+  let report;
 
   try {
     report = JSON.parse(readFileSync(reportPath, 'utf-8'));
@@ -359,7 +388,9 @@ export function verifyArxivCompileReport(options = {}) {
   }
 
   try {
-    failures.push(...validateSchema(report, readJson(pathForReport(schemaPath)), 'audrey-arxiv-compile-report'));
+    failures.push(
+      ...validateSchema(report, readJson(pathForReport(schemaPath)), 'audrey-arxiv-compile-report'),
+    );
   } catch (error) {
     failures.push(`schema: ${error.message}`);
   }
@@ -386,8 +417,13 @@ export function verifyArxivCompileReport(options = {}) {
   } else if (report.status === 'failed') {
     failures.push(...(report.failures?.length ? report.failures : ['arXiv compile failed']));
   } else if (report.status === 'passed') {
-    if (!report.outputPdf || !existsSync(fromRoot(report.outputPdf))) failures.push('arxiv-compile-report.json: outputPdf is missing');
-    if (report.outputPdf && report.outputPdfSha256 && sha256File(fromRoot(report.outputPdf)) !== report.outputPdfSha256) {
+    if (!report.outputPdf || !existsSync(fromRoot(report.outputPdf)))
+      failures.push('arxiv-compile-report.json: outputPdf is missing');
+    if (
+      report.outputPdf &&
+      report.outputPdfSha256 &&
+      sha256File(fromRoot(report.outputPdf)) !== report.outputPdfSha256
+    ) {
       failures.push('arxiv-compile-report.json: outputPdfSha256 is stale');
     }
   }

package/scripts/verify-arxiv-source.mjs

@@ -41,7 +41,8 @@ function checkSourceHash(label, sourcePath, expectedHash, failures) {
     failures.push(`arxiv-manifest.json: missing source file for ${label}: ${sourcePath}`);
     return;
   }
-  if (expectedHash !== sha256File(absolute)) failures.push(`arxiv-manifest.json: ${label} hash is stale`);
+  if (expectedHash !== sha256File(absolute))
+    failures.push(`arxiv-manifest.json: ${label} hash is stale`);
 }
 
 function parseArgs(argv = process.argv.slice(2)) {
@@ -76,7 +77,7 @@ export function verifyArxivSourcePackage(options = {}) {
   const schemaPath = fromRoot(options.schema ?? DEFAULT_SCHEMA);
   const manifestPath = join(dir, 'arxiv-manifest.json');
   const failures = [];
-  let manifest = null;
+  let manifest;
 
   try {
     manifest = readJson(manifestPath);
@@ -99,12 +100,29 @@ export function verifyArxivSourcePackage(options = {}) {
 
   const listed = new Map((manifest.files ?? []).map(file => [file.path, file]));
   for (const file of REQUIRED_FILES) {
-    if (!listed.has(file)) failures.push(`arxiv-manifest.json: missing required file record ${file}`);
+    if (!listed.has(file))
+      failures.push(`arxiv-manifest.json: missing required file record ${file}`);
   }
-  if (listed.has('arxiv-manifest.json')) failures.push('arxiv-manifest.json: must not include a self-hash file record');
-  checkSourceHash('sourceMarkdown', manifest.sourceMarkdown, manifest.sourceHashes?.sourceMarkdown, failures);
-  checkSourceHash('publicationPack', manifest.publicationPack, manifest.sourceHashes?.publicationPack, failures);
-  checkSourceHash('referencesBib', 'docs/paper/references.bib', manifest.sourceHashes?.referencesBib, failures);
+  if (listed.has('arxiv-manifest.json'))
+    failures.push('arxiv-manifest.json: must not include a self-hash file record');
+  checkSourceHash(
+    'sourceMarkdown',
+    manifest.sourceMarkdown,
+    manifest.sourceHashes?.sourceMarkdown,
+    failures,
+  );
+  checkSourceHash(
+    'publicationPack',
+    manifest.publicationPack,
+    manifest.sourceHashes?.publicationPack,
+    failures,
+  );
+  checkSourceHash(
+    'referencesBib',
+    'docs/paper/references.bib',
+    manifest.sourceHashes?.referencesBib,
+    failures,
+  );
 
   for (const [file, record] of listed) {
     const path = join(dir, file);
@@ -126,11 +144,14 @@ export function verifyArxivSourcePackage(options = {}) {
     }
   }
 
-  const actualFiles = walkFiles(dir).filter(file => file !== 'arxiv-manifest.json').sort();
+  const actualFiles = walkFiles(dir)
+    .filter(file => file !== 'arxiv-manifest.json')
+    .sort();
   const listedFiles = [...listed.keys()].sort();
   const listedSet = new Set(listedFiles);
   for (const file of actualFiles) {
-    if (!listedSet.has(file)) failures.push(`${file}: present in package but missing from manifest`);
+    if (!listedSet.has(file))
+      failures.push(`${file}: present in package but missing from manifest`);
   }
 
   const mainPath = join(dir, 'main.tex');
@@ -138,24 +159,33 @@ export function verifyArxivSourcePackage(options = {}) {
   const main = existsSync(mainPath) ? readFileSync(mainPath, 'utf-8') : '';
   const bib = existsSync(bibPath) ? readFileSync(bibPath, 'utf-8') : '';
   const citationCount = [...main.matchAll(/\\cite\{([^}]+)\}/g)].length;
-  const citedIds = new Set([...main.matchAll(/\\cite\{([^}]+)\}/g)].flatMap(match => match[1].split(',').map(id => id.trim())));
+  const citedIds = new Set(
+    [...main.matchAll(/\\cite\{([^}]+)\}/g)].flatMap(match =>
+      match[1].split(',').map(id => id.trim()),
+    ),
+  );
   const bibIds = new Set([...bib.matchAll(/@\w+\s*\{\s*([^,\s]+)/g)].map(match => match[1].trim()));
   const bibEntries = countBibEntries(bib);
 
   if (!main.includes('\\documentclass')) failures.push('main.tex: missing documentclass');
   if (!main.includes('\\begin{abstract}')) failures.push('main.tex: missing abstract');
-  if (!main.includes('\\bibliography{references}')) failures.push('main.tex: missing bibliography command');
+  if (!main.includes('\\bibliography{references}'))
+    failures.push('main.tex: missing bibliography command');
   if (main.includes('[@')) failures.push('main.tex: contains unconverted Markdown citation syntax');
-  if (/^#{1,6}\s/m.test(main)) failures.push('main.tex: contains unconverted Markdown heading syntax');
+  if (/^#{1,6}\s/m.test(main))
+    failures.push('main.tex: contains unconverted Markdown heading syntax');
   if (main.includes(SEEDED_SECRET)) failures.push('main.tex: contains seeded raw secret');
-  if (/([A-Z]:\\|file:\/\/|C:\\Users\\|B:\\Projects\\)/i.test(main)) failures.push('main.tex: contains a local absolute path');
+  if (/([A-Z]:\\|file:\/\/|C:\\Users\\|B:\\Projects\\)/i.test(main))
+    failures.push('main.tex: contains a local absolute path');
   if (citationCount < 1) failures.push('main.tex: expected at least one citation');
   if (bibEntries !== 21) failures.push(`references.bib: expected 21 entries, found ${bibEntries}`);
   for (const id of citedIds) {
     if (!bibIds.has(id)) failures.push(`main.tex: cites missing bibliography id ${id}`);
   }
-  if (manifest.tex?.citationCount !== citationCount) failures.push('arxiv-manifest.json: citation count is stale');
-  if (manifest.tex?.bibEntryCount !== bibEntries) failures.push('arxiv-manifest.json: bibliography count is stale');
+  if (manifest.tex?.citationCount !== citationCount)
+    failures.push('arxiv-manifest.json: citation count is stale');
+  if (manifest.tex?.bibEntryCount !== bibEntries)
+    failures.push('arxiv-manifest.json: bibliography count is stale');
 
   return {
     ok: failures.length === 0,

package/scripts/verify-browser-launch-plan.mjs

@@ -89,7 +89,9 @@ function isAllowedHost(platform, value) {
 }
 
 function hasPendingBoundary(text) {
-  return /\b(pending|not claim|not claimed|does not report|remain pending|live evidence|strict evidence)\b/i.test(text);
+  return /\b(pending|not claim|not claimed|does not report|remain pending|live evidence|strict evidence)\b/i.test(
+    text,
+  );
 }
 
 function validateTarget(target, entryMap, sourceIds) {
@@ -107,7 +109,9 @@ function validateTarget(target, entryMap, sourceIds) {
       continue;
     }
     if (entry.platform !== target.platform) {
-      failures.push(`${target.id}: entry ${entryId} belongs to ${entry.platform}, not ${target.platform}`);
+      failures.push(
+        `${target.id}: entry ${entryId} belongs to ${entry.platform}, not ${target.platform}`,
+      );
     }
     if (!allowedEntries.has(entryId)) {
       failures.push(`${target.id}: entry ${entryId} is not approved for ${target.platform}`);
@@ -116,7 +120,9 @@ function validateTarget(target, entryMap, sourceIds) {
       failures.push(`${target.id}: entry ${entryId} exceeds maxChars`);
     }
     if (/\b(Mem0|Zep)\b/.test(entry.text) && !hasPendingBoundary(entry.text)) {
-      failures.push(`${target.id}: entry ${entryId} mentions Mem0/Zep without pending boundary language`);
+      failures.push(
+        `${target.id}: entry ${entryId} mentions Mem0/Zep without pending boundary language`,
+      );
     }
     targetEntries.push(entry);
   }
@@ -124,7 +130,8 @@ function validateTarget(target, entryMap, sourceIds) {
     if (!sourceIds.has(sourceId)) failures.push(`${target.id}: unknown sourceRef ${sourceId}`);
   }
   for (const artifact of target.artifactRefs) {
-    if (!existsSync(fromRoot(artifact))) failures.push(`${target.id}: missing artifactRef ${artifact}`);
+    if (!existsSync(fromRoot(artifact)))
+      failures.push(`${target.id}: missing artifactRef ${artifact}`);
   }
   if (target.platform === 'reddit' && target.manualRuleCheckRequired !== true) {
     failures.push(`${target.id}: Reddit target must require a manual subreddit rule check`);
@@ -135,16 +142,21 @@ function validateTarget(target, entryMap, sourceIds) {
   if (target.platform === 'arxiv' && target.manualRuleCheckRequired !== true) {
     failures.push(`${target.id}: arXiv target must require a manual category/metadata check`);
   }
-  if (!target.humanRequired) failures.push(`${target.id}: browser launch targets must require a human operator`);
-  if (!target.authRequired) failures.push(`${target.id}: browser launch targets must require authenticated account review`);
-  if (target.operatorChecks.length < 2) failures.push(`${target.id}: operator checklist is too thin`);
+  if (!target.humanRequired)
+    failures.push(`${target.id}: browser launch targets must require a human operator`);
+  if (!target.authRequired)
+    failures.push(`${target.id}: browser launch targets must require authenticated account review`);
+  if (target.operatorChecks.length < 2)
+    failures.push(`${target.id}: operator checklist is too thin`);
   if (target.postSubmitChecks.length < 1) failures.push(`${target.id}: missing post-submit checks`);
   if (
     target.platform === 'x' &&
     target.status === 'blocked-until-artifact-url' &&
     !targetEntries.some(entry => entry.requiresArtifactUrl === true)
   ) {
-    failures.push(`${target.id}: X artifact-url launch target must include a publication entry with reserved URL budget`);
+    failures.push(
+      `${target.id}: X artifact-url launch target must include a publication entry with reserved URL budget`,
+    );
   }
 
   return failures;
@@ -160,7 +172,9 @@ export async function verifyBrowserLaunchPlan(options = {}) {
   const ids = new Set();
   const targetReports = [];
   const failures = [
-    ...validateSchema(plan, schema, 'audrey-browser-launch-plan').map(failure => `browser launch plan schema: ${failure}`),
+    ...validateSchema(plan, schema, 'audrey-browser-launch-plan').map(
+      failure => `browser launch plan schema: ${failure}`,
+    ),
   ];
 
   if (!publicationReport.ok) {
@@ -170,7 +184,8 @@ export async function verifyBrowserLaunchPlan(options = {}) {
     failures.push('browser launch plan must point at docs/paper/publication-pack.json');
   }
   for (const command of REQUIRED_PREFLIGHT_COMMANDS) {
-    if (!(plan.preflightCommands ?? []).includes(command)) failures.push(`Missing browser-launch preflight command: ${command}`);
+    if (!(plan.preflightCommands ?? []).includes(command))
+      failures.push(`Missing browser-launch preflight command: ${command}`);
   }
   for (const target of plan.targets ?? []) {
     const targetFailures = [];
@@ -192,7 +207,9 @@ export async function verifyBrowserLaunchPlan(options = {}) {
   for (const id of REQUIRED_TARGETS) {
     if (!ids.has(id)) failures.push(`Missing browser-launch target: ${id}`);
   }
-  const ordered = [...(plan.targets ?? [])].sort((a, b) => a.order - b.order).map(target => target.id);
+  const ordered = [...(plan.targets ?? [])]
+    .sort((a, b) => a.order - b.order)
+    .map(target => target.id);
   if (ordered.join('|') !== REQUIRED_TARGETS.join('|')) {
     failures.push(`Browser-launch target order must be ${REQUIRED_TARGETS.join(', ')}`);
   }