audrey 1.0.1 → 1.0.2

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(', ')}`);
   }

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

@@ -102,9 +102,11 @@ function matchesTrustedGitHubRepoUrl(value) {
   try {
     const url = new URL(value);
     const pathname = url.pathname.toLowerCase();
-    return url.protocol === TRUSTED_GITHUB_REPO.protocol
-      && url.hostname === TRUSTED_GITHUB_REPO.hostname
-      && (pathname === TRUSTED_GITHUB_REPO_PATH || pathname.startsWith(`${TRUSTED_GITHUB_REPO_PATH}/`));
+    return (
+      url.protocol === TRUSTED_GITHUB_REPO.protocol &&
+      url.hostname === TRUSTED_GITHUB_REPO.hostname &&
+      (pathname === TRUSTED_GITHUB_REPO_PATH || pathname.startsWith(`${TRUSTED_GITHUB_REPO_PATH}/`))
+    );
   } catch {
     return false;
   }
@@ -136,7 +138,9 @@ function validateResultTarget(result, planTarget) {
   }
 
   if (result.platform !== planTarget.platform) {
-    failures.push(`${result.id}: platform ${result.platform} does not match launch plan ${planTarget.platform}`);
+    failures.push(
+      `${result.id}: platform ${result.platform} does not match launch plan ${planTarget.platform}`,
+    );
   }
   if (!isAllowedPlatformUrl(result.platform, result.publicUrl)) {
     failures.push(`${result.id}: publicUrl host is not allowed for ${result.platform}`);
@@ -144,14 +148,18 @@ function validateResultTarget(result, planTarget) {
   if (!isHttpsUrl(result.artifactUrl)) {
     failures.push(`${result.id}: artifactUrl must be null or https`);
   }
-  if (text.includes(SEEDED_SECRET)) failures.push(`${result.id}: contains raw seeded GuardBench secret`);
+  if (text.includes(SEEDED_SECRET))
+    failures.push(`${result.id}: contains raw seeded GuardBench secret`);
   if (containsLocalPath(text)) failures.push(`${result.id}: contains local absolute path`);
 
   if (result.status === 'pending') {
     if (!result.blocker) failures.push(`${result.id}: pending result must record a blocker`);
-    if (result.publicUrl !== null) failures.push(`${result.id}: pending result must not record a publicUrl`);
-    if (result.submittedAt !== null) failures.push(`${result.id}: pending result must not record submittedAt`);
-    if (result.operatorVerified) failures.push(`${result.id}: pending result must not be operator verified`);
+    if (result.publicUrl !== null)
+      failures.push(`${result.id}: pending result must not record a publicUrl`);
+    if (result.submittedAt !== null)
+      failures.push(`${result.id}: pending result must not record submittedAt`);
+    if (result.operatorVerified)
+      failures.push(`${result.id}: pending result must not be operator verified`);
     blockers.push(`${result.id}: ${result.blocker ?? 'pending launch target'}`);
   }
 
@@ -160,8 +168,10 @@ function validateResultTarget(result, planTarget) {
     if (planTarget.status === 'blocked-until-artifact-url' && !result.artifactUrl) {
       failures.push(`${result.id}: submitted artifact-url target must record artifactUrl`);
     }
-    if (!result.submittedAt) failures.push(`${result.id}: submitted result must record submittedAt`);
-    if (!result.operatorVerified) failures.push(`${result.id}: submitted result must be operator verified`);
+    if (!result.submittedAt)
+      failures.push(`${result.id}: submitted result must record submittedAt`);
+    if (!result.operatorVerified)
+      failures.push(`${result.id}: submitted result must be operator verified`);
     if (planTarget.manualRuleCheckRequired && !result.manualRuleCheckCompleted) {
       failures.push(`${result.id}: submitted result must record manual rule check completion`);
     }
@@ -192,7 +202,9 @@ export async function verifyBrowserLaunchResults(options = {}) {
   const planReport = await verifyBrowserLaunchPlan({ plan: planPath });
   const planTargets = new Map((plan.targets ?? []).map(target => [target.id, target]));
   const failures = [
-    ...validateSchema(results, schema, 'audrey-browser-launch-results').map(failure => `browser launch results schema: ${failure}`),
+    ...validateSchema(results, schema, 'audrey-browser-launch-results').map(
+      failure => `browser launch results schema: ${failure}`,
+    ),
   ];
   const blockers = [];
   const seen = new Set();
@@ -225,7 +237,9 @@ export async function verifyBrowserLaunchResults(options = {}) {
     });
   }
 
-  const planOrder = [...(plan.targets ?? [])].sort((a, b) => a.order - b.order).map(target => target.id);
+  const planOrder = [...(plan.targets ?? [])]
+    .sort((a, b) => a.order - b.order)
+    .map(target => target.id);
   const resultOrder = [...(results.targets ?? [])].map(target => target.id);
   if (resultOrder.join('|') !== planOrder.join('|')) {
     failures.push(`browser launch results order must be ${planOrder.join(', ')}`);
@@ -234,7 +248,9 @@ export async function verifyBrowserLaunchResults(options = {}) {
     if (!seen.has(id)) failures.push(`Missing browser launch result: ${id}`);
   }
 
-  const notSubmitted = targetReports.filter(target => target.status !== 'submitted').map(target => target.id);
+  const notSubmitted = targetReports
+    .filter(target => target.status !== 'submitted')
+    .map(target => target.id);
   const ready = failures.length === 0 && notSubmitted.length === 0;
   if (options.strict === true && notSubmitted.length > 0) {
     failures.push(`strict launch readiness requires submitted targets: ${notSubmitted.join(', ')}`);
@@ -268,7 +284,9 @@ async function main() {
   } else if (report.ok) {
     const submitted = report.targets.filter(target => target.status === 'submitted').length;
     const pending = report.targets.length - submitted;
-    console.log(`Browser launch results verification passed: ${submitted} submitted, ${pending} pending`);
+    console.log(
+      `Browser launch results verification passed: ${submitted} submitted, ${pending} pending`,
+    );
   } else {
     console.error('Browser launch results verification failed:');
     for (const failure of report.failures) console.error(`- ${failure}`);